@goliapkg/sentori-react-native 0.9.11 → 1.0.0-rc.2

package/android/src/main/java/com/sentori/SentoriForegroundActivity.kt

@@ -0,0 +1,145 @@
+package com.sentori
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import java.lang.ref.WeakReference
+
+/**
+ * v1.0.0-rc.2 — process-wide foreground-Activity tracker.
+ *
+ * Both [SentoriScreenshotCapture] and [SentoriReplayCapture] need a
+ * pointer to the currently-foregrounded Activity to drive their
+ * native captures. The previous implementation registered each
+ * helper's own `ActivityLifecycleCallbacks` inside
+ * [SentoriCrashHandler.register], which runs from the Expo module's
+ * `OnCreate` lifecycle — **after** the MainActivity has already been
+ * resumed in the typical Insight / Expo dev-launcher topology.
+ * `ActivityLifecycleCallbacks` does not back-fill the current state,
+ * it only forwards future events, so `lastActivity` would stay null
+ * for the entire session if the user never backgrounded the app.
+ *
+ * Fix mirrors the iOS keyWindow 4-layer fallback:
+ *
+ *   1. Lifecycle callbacks track resumed/started activities going
+ *      forward (the same approach as before, kept).
+ *   2. **On first install** we also probe `ActivityThread` reflection
+ *      to back-fill whatever Activity is currently foreground, so the
+ *      already-resumed window is seen by the SDK from boot.
+ *   3. If reflection fails (e.g. on a future Android release that
+ *      removes `ActivityThread` access), the lifecycle callbacks
+ *      still catch the next foreground transition.
+ *
+ * `lastPath` carries the diagnostic provenance for `probeWireframe` /
+ * `probeScreenshot`, so the JS side (and Insight) can tell whether
+ * the SDK was working off a live lifecycle event or fell back to
+ * reflection.
+ */
+object SentoriForegroundActivity {
+
+    @Volatile private var lastActivity: WeakReference<Activity>? = null
+    @Volatile var lastPath: String = "none(not-yet-resolved)"
+        private set
+
+    /** Idempotent. Call from [SentoriCrashHandler.register]; subsequent
+     *  calls are no-ops because the same callbacks object would be
+     *  registered twice otherwise. */
+    @Volatile private var registered = false
+
+    @Synchronized
+    fun install(application: Application) {
+        if (registered) {
+            // Even on second install attempt, try the reflection
+            // back-fill again — process state may have advanced.
+            backfillFromActivityThread()
+            return
+        }
+        registered = true
+        application.registerActivityLifecycleCallbacks(object :
+            Application.ActivityLifecycleCallbacks {
+            override fun onActivityCreated(a: Activity, b: Bundle?) {
+                set(a, "lifecycle.created")
+            }
+            override fun onActivityStarted(a: Activity) {
+                set(a, "lifecycle.started")
+            }
+            override fun onActivityResumed(a: Activity) {
+                set(a, "lifecycle.resumed")
+            }
+            override fun onActivityPaused(a: Activity) {}
+            override fun onActivityStopped(a: Activity) {}
+            override fun onActivitySaveInstanceState(a: Activity, b: Bundle) {}
+            override fun onActivityDestroyed(a: Activity) {}
+        })
+        // Back-fill in case the Activity was already resumed before
+        // we got installed (the dev-launcher → MainActivity transition
+        // happens before the Expo module's OnCreate fires).
+        backfillFromActivityThread()
+    }
+
+    /** Public for tests + the helpers' own explicit `setActivity`
+     *  paths (kept for backwards-compat). */
+    fun set(activity: Activity, source: String) {
+        lastActivity = WeakReference(activity)
+        lastPath = source
+    }
+
+    fun current(): Activity? {
+        val live = lastActivity?.get()
+        if (live != null) return live
+        // Last-ditch: try reflection again in case install() ran before
+        // any Activity existed. Cheap if it fails.
+        backfillFromActivityThread()
+        return lastActivity?.get()
+    }
+
+    /**
+     * Best-effort foreground-Activity lookup using non-SDK reflection.
+     * Walks `ActivityThread.sCurrentActivityThread.mActivities` (an
+     * `ArrayMap<IBinder, ActivityClientRecord>`) and finds the record
+     * whose `paused` field is false. This is what Stetho / LeakCanary
+     * / Firebase Performance do, with the same caveat that future
+     * Android versions may break it — failures are silent and the
+     * lifecycle-callbacks path still wins.
+     *
+     * Tagged via `lastPath = "reflection.activityThread"` so the JS
+     * probe can see when reflection had to step in.
+     */
+    @Suppress("PrivateApi", "UNCHECKED_CAST")
+    private fun backfillFromActivityThread() {
+        try {
+            val activityThreadClass = Class.forName("android.app.ActivityThread")
+            val currentActivityThread = activityThreadClass
+                .getDeclaredMethod("currentActivityThread")
+                .also { it.isAccessible = true }
+                .invoke(null) ?: return
+            val activitiesField = activityThreadClass
+                .getDeclaredField("mActivities")
+                .also { it.isAccessible = true }
+            val activities = activitiesField.get(currentActivityThread) ?: return
+
+            // ArrayMap<IBinder, ActivityClientRecord> — iterate via reflection
+            // so we don't have to depend on the (also private) ArrayMap shape.
+            val valuesIter = (activities as? Map<*, *>)?.values?.iterator() ?: return
+            while (valuesIter.hasNext()) {
+                val record = valuesIter.next() ?: continue
+                val recordClass = record.javaClass
+                val pausedField = try {
+                    recordClass.getDeclaredField("paused").also { it.isAccessible = true }
+                } catch (_: NoSuchFieldException) { null }
+                val activityField = try {
+                    recordClass.getDeclaredField("activity").also { it.isAccessible = true }
+                } catch (_: NoSuchFieldException) { null } ?: continue
+                val paused = pausedField?.getBoolean(record) ?: false
+                val candidate = activityField.get(record) as? Activity ?: continue
+                if (!paused && !candidate.isFinishing && !candidate.isDestroyed) {
+                    set(candidate, "reflection.activityThread")
+                    return
+                }
+            }
+        } catch (_: Throwable) {
+            // Reflection unavailable; the lifecycle-callbacks path
+            // will still catch the next foreground transition.
+        }
+    }
+}

package/android/src/main/java/com/sentori/SentoriModule.kt

@@ -34,6 +34,19 @@ class SentoriModule : Module() {
             SentoriReplayCapture.captureWireframe(maskedIds)
         }
 
+        // v0.9.12 — diagnostic readout for replay. See iOS side.
+        Function("probeWireframe") {
+            SentoriReplayCapture.probe()
+        }
+
+        // v1.0.0-rc.2 — diagnostic readout for screenshot. Surfaces
+        // foreground-Activity provenance, decor-view state, and the
+        // last failure reason so the JS side can ship raw state back
+        // when screenshot returns null.
+        Function("probeScreenshot") {
+            SentoriScreenshotCapture.probe()
+        }
+
         // v0.9.4 #1 — Mobile Vitals exposure.
         Function("markJsBridgeReady") {
             SentoriMobileVitals.markJsBridgeReady()

package/android/src/main/java/com/sentori/SentoriReplayCapture.kt

@@ -9,7 +9,6 @@ import android.widget.ImageView
 import android.widget.TextView
 import org.json.JSONArray
 import org.json.JSONObject
-import java.lang.ref.WeakReference
 
 /**
  * v0.9.6 #2 — wireframe session replay (Android side).
@@ -27,34 +26,55 @@ object SentoriReplayCapture {
 
     private const val MAX_NODES = 800
 
-    @Volatile private var lastActivity: WeakReference<Activity>? = null
+    // v0.9.12 — diagnostic readout so the JS side can ask "why is the
+    // ring empty?" without parsing logcat. Mirrors the iOS side.
+    @Volatile private var lastDiagPath: String = "none(not-yet-called)"
+    @Volatile private var lastDiagNodes: Int = 0
 
+    @JvmStatic
+    fun probe(): Map<String, Any> {
+        val activity = SentoriForegroundActivity.current()
+        return mapOf(
+            "lastPath" to lastDiagPath,
+            "lastNodes" to lastDiagNodes,
+            "trackedSource" to SentoriForegroundActivity.lastPath,
+            "trackedActivity" to (activity?.javaClass?.name ?: "null"),
+            "decorViewFound" to (activity?.window?.decorView != null),
+        )
+    }
+
+    /** Backwards compat — pre-rc.2 callers that hand-fed an Activity
+     *  through `setActivity` still work; we forward to the shared
+     *  tracker so screenshot + replay both see it. */
     @JvmStatic
     fun setActivity(activity: Activity?) {
-        lastActivity = activity?.let { WeakReference(it) }
+        if (activity != null) SentoriForegroundActivity.set(activity, "manual.setActivity")
     }
 
-    /** Attach an ActivityLifecycleCallbacks so future
-     *  `captureWireframe()` calls know which Activity to walk. */
+    /** Idempotent. Wires the replay helper into the shared tracker;
+     *  kept as a public entrypoint for backwards compat with existing
+     *  call sites. */
     @JvmStatic
     fun register(application: android.app.Application) {
-        application.registerActivityLifecycleCallbacks(object :
-            android.app.Application.ActivityLifecycleCallbacks {
-            override fun onActivityCreated(a: Activity, b: android.os.Bundle?) { setActivity(a) }
-            override fun onActivityStarted(a: Activity) { setActivity(a) }
-            override fun onActivityResumed(a: Activity) { setActivity(a) }
-            override fun onActivityPaused(a: Activity) {}
-            override fun onActivityStopped(a: Activity) {}
-            override fun onActivitySaveInstanceState(a: Activity, b: android.os.Bundle) {}
-            override fun onActivityDestroyed(a: Activity) {}
-        })
+        SentoriForegroundActivity.install(application)
     }
 
     @JvmStatic
     fun captureWireframe(maskedIds: List<String>): String? {
-        val activity = lastActivity?.get() ?: return null
-        val root = activity.window?.decorView ?: return null
-        if (root.width <= 0 || root.height <= 0) return null
+        val activity = SentoriForegroundActivity.current()
+        if (activity == null) {
+            lastDiagPath = "activity.null"
+            return null
+        }
+        val root = activity.window?.decorView
+        if (root == null) {
+            lastDiagPath = "decorView.null"
+            return null
+        }
+        if (root.width <= 0 || root.height <= 0) {
+            lastDiagPath = "root.zero-size"
+            return null
+        }
 
         val maskedSet = maskedIds.toHashSet()
         val nodes = JSONArray()
@@ -62,6 +82,9 @@ object SentoriReplayCapture {
         val rootLoc = IntArray(2).also { root.getLocationInWindow(it) }
         walk(root, false, maskedSet, rootLoc, rect, nodes)
 
+        lastDiagPath = "ok(${SentoriForegroundActivity.lastPath})"
+        lastDiagNodes = nodes.length()
+
         val payload = JSONObject().apply {
             put("ts", System.currentTimeMillis())
             put("width", root.width)

package/android/src/main/java/com/sentori/SentoriScreenshotCapture.kt

@@ -1,13 +1,11 @@
 package com.sentori
 
-import android.app.Activity
 import android.app.Application
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Paint
 import android.os.Build
-import android.os.Bundle
 import android.os.Handler
 import android.os.HandlerThread
 import android.util.Base64
@@ -16,7 +14,6 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.Window
 import java.io.ByteArrayOutputStream
-import java.lang.ref.WeakReference
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import org.json.JSONArray
@@ -60,36 +57,44 @@ object SentoriScreenshotCapture {
     private const val MAX_NODES = 1500
     private const val PIXEL_COPY_TIMEOUT_MS = 200L
 
-    /// Latest activity we've seen via `ActivityLifecycleCallbacks` —
-    /// used to find the window to screenshot when neither the JS
-    /// side (which knows of `Activity.this` via React Native) nor
-    /// the crash handler hands one to us.
-    @Volatile private var lastActivity: WeakReference<Activity>? = null
+    // v1.0.0-rc.2 — diagnostic readout so the JS side can ask
+    // "why did screenshot return null" without parsing logcat. Mirrors
+    // SentoriReplayCapture.probe() and the iOS Swift probe.
+    @Volatile private var lastDiagPath: String = "none(not-yet-called)"
+    @Volatile private var lastDiagW: Int = 0
+    @Volatile private var lastDiagH: Int = 0
 
     /**
-     * Attach an `ActivityLifecycleCallbacks` so subsequent
-     * `captureScreen()` calls know which Activity (and therefore
-     * Window) to target. Idempotent; call from
-     * `SentoriCrashHandler.register(context)`.
+     * Snapshot of the most recent capture attempt — what code path
+     * resolved an Activity, what the decor view's dimensions were,
+     * and what call source the foreground tracker last saw the
+     * Activity from. Used by `probeNativeScreenshot()` on the JS
+     * side so Insight can ship raw diagnostic state back without
+     * needing logcat access.
+     */
+    @JvmStatic
+    fun probe(): Map<String, Any> {
+        val tracked = SentoriForegroundActivity.current()
+        return mapOf(
+            "lastPath" to lastDiagPath,
+            "lastWidth" to lastDiagW,
+            "lastHeight" to lastDiagH,
+            "trackedSource" to SentoriForegroundActivity.lastPath,
+            "trackedActivity" to (tracked?.javaClass?.name ?: "null"),
+            "decorViewFound" to (tracked?.window?.decorView != null),
+        )
+    }
+
+    /**
+     * Idempotent. Wires the screenshot helper into the shared
+     * foreground-activity tracker; kept as a public entrypoint for
+     * backwards compat with existing call sites (the crash handler
+     * still calls this), but the actual lifecycle subscription lives
+     * in [SentoriForegroundActivity].
      */
     @JvmStatic
     fun register(application: Application) {
-        application.registerActivityLifecycleCallbacks(object :
-            Application.ActivityLifecycleCallbacks {
-            override fun onActivityCreated(a: Activity, b: Bundle?) {
-                lastActivity = WeakReference(a)
-            }
-            override fun onActivityStarted(a: Activity) {
-                lastActivity = WeakReference(a)
-            }
-            override fun onActivityResumed(a: Activity) {
-                lastActivity = WeakReference(a)
-            }
-            override fun onActivityPaused(a: Activity) {}
-            override fun onActivityStopped(a: Activity) {}
-            override fun onActivitySaveInstanceState(a: Activity, b: Bundle) {}
-            override fun onActivityDestroyed(a: Activity) {}
-        })
+        SentoriForegroundActivity.install(application)
     }
 
     /**
@@ -102,8 +107,16 @@ object SentoriScreenshotCapture {
      */
     @JvmStatic
     fun captureKeyWindow(): Map<String, Any>? {
-        val activity = lastActivity?.get() ?: return null
-        val window = activity.window ?: return null
+        val activity = SentoriForegroundActivity.current()
+        if (activity == null) {
+            lastDiagPath = "activity.null"
+            return null
+        }
+        val window = activity.window
+        if (window == null) {
+            lastDiagPath = "window.null"
+            return null
+        }
         val out = mutableMapOf<String, Any>()
         captureScreen(window, emptySet())?.let { (base64, mediaType) ->
             out["screenshot"] = mapOf("base64" to base64, "mediaType" to mediaType)
@@ -120,8 +133,16 @@ object SentoriScreenshotCapture {
     /// masked subview's frame on the captured bitmap.
     @JvmStatic
     fun captureScreenshotWithMask(maskedIds: List<String>): Map<String, String>? {
-        val activity = lastActivity?.get() ?: return null
-        val window = activity.window ?: return null
+        val activity = SentoriForegroundActivity.current()
+        if (activity == null) {
+            lastDiagPath = "activity.null"
+            return null
+        }
+        val window = activity.window
+        if (window == null) {
+            lastDiagPath = "window.null"
+            return null
+        }
         val (base64, mediaType) = captureScreen(window, maskedIds.toHashSet()) ?: return null
         return mapOf("base64" to base64, "mediaType" to mediaType)
     }
@@ -135,12 +156,22 @@ object SentoriScreenshotCapture {
             // requires the activity not to be torn down. Skip for
             // now; v0.6.1 SDK can add the fallback if real-world
             // data shows we have users below API 24.
+            lastDiagPath = "api.unsupported"
+            return null
+        }
+        val decor = window.decorView
+        if (decor == null) {
+            lastDiagPath = "decorView.null"
             return null
         }
-        val decor = window.decorView ?: return null
         val w = decor.width
         val h = decor.height
-        if (w <= 0 || h <= 0) return null
+        lastDiagW = w
+        lastDiagH = h
+        if (w <= 0 || h <= 0) {
+            lastDiagPath = "decorView.zero-size"
+            return null
+        }
 
         // Long-edge scale.
         val longEdge = maxOf(w, h).toFloat()
@@ -175,12 +206,17 @@ object SentoriScreenshotCapture {
                 )
             }
             latch.await(PIXEL_COPY_TIMEOUT_MS, TimeUnit.MILLISECONDS)
-        } catch (_: Throwable) {
+        } catch (t: Throwable) {
+            lastDiagPath = "pixelCopy.threw:${t.javaClass.simpleName}"
             return null
         } finally {
             handlerThread.quitSafely()
         }
-        if (!success) return null
+        if (!success) {
+            lastDiagPath = "pixelCopy.notSuccess"
+            return null
+        }
+        lastDiagPath = "ok"
 
         // v0.7.3 — paint black rectangles over masked subviews on the
         // already-captured bitmap. We get window-relative coordinates

package/ios/SentoriModule.swift

@@ -30,6 +30,21 @@ public class SentoriModule: Module {
             return SentoriReplayCapture.captureWireframe(maskedIds: maskedIds)
         }
 
+        // v0.9.12 — diagnostic readout for replay. Returns the last
+        // keyWindow resolution path + scene/window counts so a single
+        // JS-side button can answer "why is my ring empty?" without
+        // re-rolling the pod. See SentoriReplayCapture.swift.
+        Function("probeWireframe") { () -> [String: Any] in
+            return SentoriReplayCapture.probe()
+        }
+
+        // v1.0.0-rc.2 — diagnostic readout for screenshot. Same shape
+        // as Android side; lets Insight ship raw state back when the
+        // captureScreenshot path returns null.
+        Function("probeScreenshot") { () -> [String: Any] in
+            return SentoriScreenshotCapture.probe()
+        }
+
         // v0.9.4 #1 — Mobile Vitals exposure.
         Function("markJsBridgeReady") {
             SentoriMobileVitals.markJsBridgeReady()

package/ios/SentoriReplayCapture.swift

@@ -29,8 +29,33 @@ import UIKit
         return result
     }
 
+    /// Last path the keyWindow lookup took. Exposed to JS via
+    /// `probeWireframe()` so the failure-mode diagnostic in Metro can
+    /// tell scene-race from "no window at all" without re-rolling the
+    /// pod. Updated on every captureSync call.
+    @objc public static var lastDiagPath: String = "none(not-yet-called)"
+    @objc public static var lastDiagNodes: Int = 0
+    @objc public static var lastDiagSceneCount: Int = 0
+    @objc public static var lastDiagWindowCount: Int = 0
+    private static var loggedFirstResult = false
+
     private static func captureSync(maskedIds: Set<String>) -> String? {
-        guard let window = keyWindow() else { return nil }
+        let (winOpt, path) = resolveKeyWindow()
+        lastDiagPath = path
+        lastDiagSceneCount = currentSceneCount()
+        lastDiagWindowCount = currentWindowCount()
+        guard let window = winOpt else {
+            if !loggedFirstResult {
+                NSLog(
+                    "[sentori] wireframe: returning nil — keyWindow path=%@ scenes=%d windows=%d",
+                    path,
+                    lastDiagSceneCount,
+                    lastDiagWindowCount
+                )
+                loggedFirstResult = true
+            }
+            return nil
+        }
         var nodes: [[String: Any]] = []
         walk(
             view: window,
@@ -39,6 +64,17 @@ import UIKit
             window: window,
             nodes: &nodes
         )
+        lastDiagNodes = nodes.count
+        if !loggedFirstResult {
+            NSLog(
+                "[sentori] wireframe: first capture ok — keyWindow path=%@ bounds=%.0fx%.0f nodes=%d",
+                path,
+                window.bounds.width,
+                window.bounds.height,
+                nodes.count
+            )
+            loggedFirstResult = true
+        }
         let payload: [String: Any] = [
             "ts": Int(Date().timeIntervalSince1970 * 1000),
             "width": Double(window.bounds.width),
@@ -51,19 +87,77 @@ import UIKit
         return nil
     }
 
-    private static func keyWindow() -> UIWindow? {
+    /// Four-tier window resolution. The previous single-pass loop
+    /// returned nil whenever the first connected scene was a
+    /// `.background` or `.unattached` SwiftUI/preview scene that had
+    /// no windows yet — common on iOS 26 cold-start where the JS
+    /// thread spins up the replay tick before scene activation
+    /// settles (the v0.9.6 default 1 Hz fires within ~200 ms).
+    private static func resolveKeyWindow() -> (UIWindow?, String) {
         if #available(iOS 13.0, *) {
-            for scene in UIApplication.shared.connectedScenes {
-                guard let ws = scene as? UIWindowScene else { continue }
-                if let key = ws.windows.first(where: { $0.isKeyWindow }) {
-                    return key
+            let scenes = Array(UIApplication.shared.connectedScenes)
+            // Pass 1: foregroundActive scene with a key window.
+            for scene in scenes where scene.activationState == .foregroundActive {
+                if let ws = scene as? UIWindowScene,
+                   let key = ws.windows.first(where: { $0.isKeyWindow }) {
+                    return (key, "scene.fg.key")
+                }
+            }
+            // Pass 2: foregroundActive scene's first window (no key set yet).
+            for scene in scenes where scene.activationState == .foregroundActive {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.fg.first")
+                }
+            }
+            // Pass 3: foregroundInactive (mid-transition) scene with any window.
+            for scene in scenes where scene.activationState == .foregroundInactive {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.fgi.first")
                 }
-                if let first = ws.windows.first {
-                    return first
+            }
+            // Pass 4: any scene at all with windows.
+            for scene in scenes {
+                if let ws = scene as? UIWindowScene, let win = ws.windows.first {
+                    return (win, "scene.any.first")
                 }
             }
+            // Fallthrough → legacy windows list.
+        }
+        if let leg = UIApplication.shared.windows.first {
+            return (leg, "legacy.first")
         }
-        return UIApplication.shared.windows.first
+        return (nil, "none")
+    }
+
+    private static func currentSceneCount() -> Int {
+        if #available(iOS 13.0, *) {
+            return UIApplication.shared.connectedScenes.count
+        }
+        return 0
+    }
+
+    private static func currentWindowCount() -> Int {
+        if #available(iOS 13.0, *) {
+            return UIApplication.shared.connectedScenes.reduce(0) { acc, scene in
+                acc + ((scene as? UIWindowScene)?.windows.count ?? 0)
+            }
+        }
+        return UIApplication.shared.windows.count
+    }
+
+    /// JS-side probe. Returns a dict the example/dashboard can render
+    /// to ask "why is the ring empty?" without parsing Metro logs.
+    /// `lastNodes == 0 && lastPath != "none"` means the window walk
+    /// happened but the tree was empty (unusual — backgrounded?).
+    /// `lastPath == "none(...)"` means no UIWindow was reachable at
+    /// the moment of the last tick.
+    @objc public static func probe() -> [String: Any] {
+        return [
+            "lastPath": lastDiagPath,
+            "lastNodes": lastDiagNodes,
+            "sceneCount": lastDiagSceneCount,
+            "windowCount": lastDiagWindowCount,
+        ]
     }
 
     /// Cap on nodes per snapshot — extremely deep / wide trees can