@goliapkg/sentori-react-native 6.2.0 → 6.3.0

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

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriFirebaseMessagingService.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // v2.10 — FCM message routing service.
 //
 // Manifest-registered in `AndroidManifest.xml`. Firebase's manifest
@@ -30,6 +33,11 @@ class SentoriFirebaseMessagingService : FirebaseMessagingService() {
         super.onNewToken(token)
         try {
             SentoriPushNotifications.handleRegisteredToken(token)
+            // And tell the server, now. Buffering it in a field was
+            // the whole of what happened here before, so a rotation
+            // was invisible until the host next called `register` —
+            // and the device received nothing in between.
+            SentoriPush.handleRotatedToken(applicationContext, token)
         } catch (_: Throwable) {
             // never crash a Firebase callback
         }
@@ -49,6 +57,16 @@ class SentoriFirebaseMessagingService : FirebaseMessagingService() {
                 notif.channelId?.let { payload["channelId"] = it }
             }
             SentoriPushNotifications.handleIncomingNotification(payload)
+
+            // A `data` message is invisible until somebody draws it,
+            // and the Sentori server sends `data` on purpose so that
+            // the tap comes back through a pending intent we own. If
+            // the system already drew this one — a `notification`
+            // message from some other sender — leave it alone rather
+            // than showing it twice.
+            if (message.notification == null) {
+                SentoriPushNotifications.postNotification(applicationContext, message.data)
+            }
         } catch (_: Throwable) {
             // never crash a Firebase callback
         }

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

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriForegroundActivity.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/SentoriIdentity.kt

@@ -0,0 +1,101 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriIdentity.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.security.MessageDigest
+
+/**
+ * Turns a raw identity into the key that travels on the wire.
+ *
+ * Every event carries `userKey`, and a registered device carries the
+ * same one — that join is what lets an issue reach the people it
+ * happened to. The raw value never leaves the device; only this hash
+ * does.
+ *
+ * Three implementations now compute it: TypeScript in
+ * `sdk/core/src/identity.ts`, Swift, and this. They must agree byte
+ * for byte. If they drift, a device stops matching the events from
+ * the same person: the push reaches nobody and nothing reports it,
+ * which is precisely why a second implementation is a bad idea unless
+ * something is holding the three together.
+ *
+ * That something is `sdk/native/fixtures/identity-vectors.json`,
+ * generated by the TypeScript module and asserted by both native
+ * suites.
+ *
+ * The client hash is unsalted. The server layers its own per-scope
+ * salt before storing a fingerprint; several comments in this
+ * codebase call the client value "salted", and they are wrong.
+ */
+object SentoriIdentity {
+
+    /**
+     * SHA-256 of the normalised value, lowercase hex. `null` for an
+     * empty or whitespace-only input — no key beats a meaningless
+     * one, and the caller treats absent as "broadcast only".
+     */
+    @JvmStatic
+    fun hash(keyType: String, value: String?): String? {
+        if (value == null) return null
+        val normalised = normalise(keyType, value)
+        if (normalised.isEmpty()) return null
+        val digest = MessageDigest.getInstance("SHA-256")
+            .digest(normalised.toByteArray(Charsets.UTF_8))
+        val out = StringBuilder(64)
+        for (b in digest) {
+            val v = b.toInt() and 0xff
+            out.append(HEX[v ushr 4]).append(HEX[v and 0x0f])
+        }
+        return out.toString()
+    }
+
+    /**
+     * The key for a user, matching `scope.ts`: the id if there is one,
+     * otherwise the email. Not both — one device, one key.
+     */
+    @JvmStatic
+    fun userKey(id: String?, email: String?): String? =
+        hash("id", id) ?: hash("email", email)
+
+    /**
+     * Well-known normalisations, mirroring `normalise` in
+     * `identity.ts`. A type this does not know about gets a plain
+     * trim, which is that function's `default` branch.
+     */
+    /**
+     * What the other two implementations strip.
+     *
+     * Kotlin's `trim()` uses `Character.isWhitespace`, which counts
+     * neither U+00A0 (no-break space) nor U+FEFF (byte-order mark).
+     * ECMAScript's `WhiteSpace` production counts both, so JavaScript
+     * strips them. Swift's `.whitespacesAndNewlines` counts the first
+     * and not the second, so it needed a fix of its own.
+     *
+     * Three languages, three definitions of blank. A value pasted from
+     * a web page routinely carries these, and any of the defaults
+     * would have made one device hash differently from its own events
+     * — for one user, silently, on the path nobody watches.
+     *
+     * Caught by the shared vectors before it shipped, which is what
+     * they are for.
+     */
+    private fun String.trimLikeTheOthers(): String =
+        trim { it.isWhitespace() || it == '\u00a0' || it == '\ufeff' }
+
+    @JvmStatic
+    internal fun normalise(keyType: String, raw: String): String = when (keyType) {
+        "email", "username" -> raw.trimLikeTheOthers().lowercase()
+        // Everything that is not `+` or an ASCII digit goes, so
+        // "+81 (90) 1234-5678" and "+819012345678" agree. Deliberately
+        // not E.164 validation — that is the host's business; this
+        // only removes formatting noise.
+        "phone" -> raw.filter { it == '+' || it in '0'..'9' }
+        // OAuth subject claims are opaque. Touching them would change
+        // an identifier the provider defined.
+        "googleSub", "appleSub", "metaSub" -> raw
+        else -> raw.trimLikeTheOthers()
+    }
+
+    private val HEX = "0123456789abcdef".toCharArray()
+}

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

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

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

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

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

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

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

@@ -0,0 +1,148 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriNotificationTap.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import android.app.Activity
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+
+/**
+ * Taps, delivered without asking the host for anything.
+ *
+ * `handleNotificationTap` used to be the only way a tap reached
+ * `register(onTap:)`, and its own comment said the host wires this in
+ * `Activity.onCreate to forward the intent extras`. Nothing in the SDK
+ * called it, the public docs never mentioned it, and so a native host
+ * passed an `onTap` callback that could not fire. insight measured
+ * that: the tray entry appeared, the app opened, and the callback
+ * stayed silent. It is the same shape as the permission bug — a
+ * premise carried over from the React Native integration, where the
+ * host module did the forwarding, and quietly false everywhere else.
+ *
+ * There are two ways a tap can reach an app, and this covers both.
+ *
+ * **A notification the SDK posted.** The pending intent is ours, so
+ * the tap arrives here with the message that produced it. Nothing can
+ * intercept it and nothing needs to cooperate. This is the path the
+ * Sentori server produces, because it sends `data` messages for
+ * exactly this reason.
+ *
+ * **A notification the system posted**, from a `notification` message
+ * some other sender emitted. The system opens the launcher activity
+ * with the payload in the intent extras and never calls our service.
+ * All that can be done is to read the intent the Activity was handed,
+ * which `register` does. A tap that arrives while the app is already
+ * running reaches the host's `onNewIntent`, and only a host that
+ * calls `setIntent` makes it visible to anyone else — so that case
+ * still needs the host, and the documentation says so rather than
+ * pretending otherwise.
+ */
+object SentoriNotificationTap {
+
+    /** Extras on our own pending intent. */
+    const val EXTRA_MARKER = "com.sentori.tap"
+
+    /**
+     * FCM stamps this on anything it delivers. Its presence is how an
+     * ordinary launch is told apart from a notification tap when the
+     * system posted the notification.
+     */
+    private const val FCM_MESSAGE_ID = "google.message_id"
+
+    private val lock = Any()
+    private val seen = ArrayDeque<String>()
+    private const val SEEN_CAP = 32
+
+    /**
+     * A tap is delivered once.
+     *
+     * The same intent is visible to `register` on a cold start and to
+     * the pending intent that caused it, and an Activity that is
+     * recreated on rotation hands back the intent it launched with.
+     * Reporting a tap twice makes a host count one open as two.
+     */
+    private fun firstTime(id: String): Boolean = synchronized(lock) {
+        if (seen.contains(id)) return false
+        seen.addLast(id)
+        while (seen.size > SEEN_CAP) seen.removeFirst()
+        true
+    }
+
+    /** The pending intent attached to a notification the SDK posts. */
+    fun pendingIntent(ctx: Context, data: Map<String, String>, requestCode: Int): PendingIntent? {
+        // `getLaunchIntentForPackage` returns null more often than it
+        // looks: an app with no exported launcher activity, and any
+        // Robolectric host. The first version gave up there and
+        // posted a notification with no content intent — a tray entry
+        // that swallows the tap, which is worse than the bug this
+        // file exists to fix, because it looks like it works.
+        val launch = ctx.packageManager.getLaunchIntentForPackage(ctx.packageName)
+            ?: Intent(Intent.ACTION_MAIN)
+                .addCategory(Intent.CATEGORY_LAUNCHER)
+                .setPackage(ctx.packageName)
+        launch.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        launch.putExtra(EXTRA_MARKER, true)
+        for ((k, v) in data) launch.putExtra(k, v)
+        return PendingIntent.getActivity(
+            ctx,
+            requestCode,
+            launch,
+            // Immutable is required from Android 12 and correct
+            // everywhere: nothing downstream should be able to rewrite
+            // the payload this carries.
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+    }
+
+    /**
+     * Read whatever launched this Activity and report a tap if that is
+     * what it was.
+     *
+     * Called by `register`, so a host that does nothing at all still
+     * gets its `onTap`.
+     */
+    fun consume(activity: Activity?) {
+        consume(activity?.intent?.extras)
+    }
+
+    /**
+     * Report a tap from intent extras, if that is what they are.
+     *
+     * Public because the documentation asks hosts to call it. A tap
+     * arriving while the app is already running reaches the host's
+     * `onNewIntent` and nowhere else, and the docs said so — while
+     * this object was `internal`, so the only reachable alternative
+     * was `handleNotificationTap`, which records whatever it is
+     * given. insight ended up copying the two-key test out of here by
+     * hand, including a constant that exists only in this file.
+     *
+     * Safe to call with any intent's extras: an ordinary launch is
+     * not a tap and is ignored, and the same tap is reported once.
+     */
+    fun consume(extras: Bundle?) {
+        val bundle = extras ?: return
+        val ours = bundle.getBoolean(EXTRA_MARKER, false)
+        val fcm = bundle.containsKey(FCM_MESSAGE_ID)
+        // An ordinary launch has neither, and reporting it as a tap
+        // would put a notification in every session that never had
+        // one.
+        if (!ours && !fcm) return
+
+        val payload = mutableMapOf<String, Any?>()
+        for (key in bundle.keySet()) {
+            if (key == EXTRA_MARKER) continue
+            payload[key] = bundle.get(key)
+        }
+        val id = (bundle.getString(FCM_MESSAGE_ID) ?: payload["id"] as? String)
+            ?: payload.toString()
+        if (!firstTime(id)) return
+        SentoriPushNotifications.handleNotificationTap(payload)
+    }
+
+    internal fun resetForTests() {
+        synchronized(lock) { seen.clear() }
+    }
+}

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

@@ -0,0 +1,154 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriPendingCrash.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * The crash that killed the app, sent on the next launch.
+ *
+ * [SentoriCrashHandler] writes one JSON file per crash from inside an
+ * uncaught-exception handler, where almost nothing is safe to do — so
+ * it writes a flat, older shape and gets out. Something has to read
+ * those files, convert them to the wire format and enqueue them, and
+ * until now nothing in this package did: the crash handler filled a
+ * directory nobody emptied.
+ *
+ * React Native has had the missing half since the beginning, in
+ * `sdk/react-native/src/native-pending.ts`. This is the same
+ * conversion as that and as the Swift one, so a crash arrives
+ * identical whichever SDK sent it — the dashboard cannot tell and
+ * should not have to.
+ *
+ * Attachments captured before death are carried in the file and are
+ * **not** uploaded yet: that needs the attachment endpoint this
+ * package does not speak. They are left in place rather than silently
+ * dropped, and the event ships without them — a crash report with no
+ * screenshot beats no crash report.
+ */
+internal object SentoriPendingCrash {
+
+    /** Drain, convert, enqueue. Called once by [Sentori.start]. */
+    fun ship() {
+        val files = SentoriCrashHandler.consumePending()
+        if (files.isEmpty()) return
+
+        for (text in files) {
+            val raw =
+                try {
+                    JSONObject(text)
+                } catch (_: Throwable) {
+                    // One corrupt file must not cost the others.
+                    continue
+                }
+            // The screenshot and view tree the handler captured as the
+            // app died. They travel in the file and never on the wire —
+            // the server takes them separately, keyed on an event it
+            // must already have.
+            val blobs = raw.optJSONArray("_pendingAttachments")
+            raw.remove("_pendingAttachments")
+            val wire = toWire(raw)
+            val id = wire["id"] as? String
+
+            // Registered before this event is queued, and keyed on its
+            // id. Two races close here, and one of them was real: the
+            // first version registered after `flush`, which hands the
+            // send to a worker and returns — so on a fast network the
+            // batch was accepted before the block existed and the
+            // attachments never uploaded at all. Registering before the
+            // loop's flush is not enough either, since `enqueue` sends
+            // of its own accord once ten events are queued, and a run
+            // with ten crash files would flush mid-loop.
+            if (blobs != null && blobs.length() > 0 && id != null) {
+                SentoriTransport.afterDelivery(setOf(id)) {
+                    for (i in 0 until blobs.length()) {
+                        val blob = blobs.optJSONObject(i) ?: continue
+                        val kind = blob.optString("kind", "")
+                        val base64 = blob.optString("base64", "")
+                        if (kind.isEmpty() || base64.isEmpty()) continue
+                        SentoriAttachment.upload(
+                            eventId = id,
+                            kind = kind,
+                            base64 = base64,
+                            mediaType =
+                                blob.optString("mediaType", "").ifEmpty {
+                                    "application/octet-stream"
+                                },
+                            source = blob.optString("source", "").ifEmpty { "android" },
+                        )
+                    }
+                }
+            }
+            SentoriTransport.enqueue(wire)
+        }
+        SentoriTransport.flush()
+    }
+
+    /**
+     * The flat on-disk shape into the nested wire one. Mirrors
+     * `toWire` in `native-pending.ts` and `SentoriPendingCrash.swift`
+     * field for field.
+     */
+    fun toWire(raw: JSONObject): Map<String, Any?> {
+        val rawError = raw.optJSONObject("error") ?: JSONObject()
+        val rawStack = rawError.optJSONArray("stack") ?: JSONArray()
+        val frames =
+            (0 until rawStack.length()).mapNotNull { i ->
+                val f = rawStack.optJSONObject(i) ?: return@mapNotNull null
+                buildMap<String, Any?> {
+                    f.optString("file", "").takeIf { it.isNotEmpty() }?.let { put("file", it) }
+                    f.optString("function", "").takeIf { it.isNotEmpty() }
+                        ?.let { put("function", it) }
+                    if (f.has("line")) put("line", f.optInt("line"))
+                    if (f.has("inApp")) put("inApp", f.optBoolean("inApp"))
+                }
+            }
+
+        val payload =
+            mutableMapOf<String, Any?>(
+                "error" to
+                    mapOf(
+                        // A crash with no type is still a crash. The
+                        // default names what it is rather than leaving
+                        // the issue title empty.
+                        "type" to
+                            rawError.optString("type", "").ifEmpty { "NativeCrash" },
+                        "message" to rawError.optString("message", ""),
+                        "stack" to frames,
+                    ),
+                // Tells the dashboard this arrived from the grave
+                // rather than from a caught error — the difference
+                // between "the app died" and "the app noticed".
+                "nativeCrash" to true,
+            )
+        raw.optJSONObject("device")?.let { payload["device"] = it.toMap() }
+        raw.optJSONObject("app")?.let { payload["app"] = it.toMap() }
+
+        return mapOf(
+            "id" to raw.optString("id", "").ifEmpty { Sentori.newEventId() },
+            "kind" to "error",
+            // The file says `timestamp`; the wire says `occurredAt`.
+            // Keeping the crash's own time matters — it is the moment
+            // the app died, not the moment the next launch noticed.
+            "occurredAt" to
+                raw.optString("timestamp", "").ifEmpty {
+                    Sentori.iso8601(java.util.Date())
+                },
+            "platform" to if (raw.optString("platform") == "ios") "ios" else "android",
+            "release" to raw.optString("release", ""),
+            "environment" to raw.optString("environment", ""),
+            "payload" to payload,
+        )
+    }
+
+    private fun JSONObject.toMap(): Map<String, Any?> =
+        keys().asSequence().associateWith { k ->
+            when (val v = get(k)) {
+                is JSONObject -> v.toMap()
+                JSONObject.NULL -> null
+                else -> v
+            }
+        }
+}