@akhilpulse/samadhaan-session-replay 0.4.2 → 0.4.3

package/README.md

@@ -167,6 +167,7 @@ After installing native deps on Android, **rebuild the app**
 4. Pause screenshot capture while the iOS keyboard is visible.
 5. Auto-mount the guided-tour overlay inside the provider, and singleton-guard it.
 6. **Android elevated views & screenshots.** `react-native-view-shot` uses a software canvas draw on Android (`view.draw(canvas)`) which silently skips any view promoted to a hardware compositor layer (anything with `elevation > 0` or `zIndex > 0` — RN implements `zIndex` via `setElevation` on Android). To work around this, **starting in 0.3.0 the SDK ships its own native module that captures via Android's `PixelCopy` API** (real on-screen pixels, including hardware layers, modals, FABs, and native `SurfaceView`s like `react-native-maps`). This module is autolinked — **after upgrading the SDK on Android you must rebuild the app** (`cd android && ./gradlew clean && cd .. && npx react-native run-android`) for the new screenshot path to activate. If the native module isn't present at runtime (older build, Expo Go), the SDK transparently falls back to `captureScreen` and the elevation limitation re-applies. Requires Android 7.0+ (API 24).
+7. **GPU-busy crash hardening (0.4.3).** On some Adreno devices, queueing PixelCopy readbacks while the GPU is saturated (maps / navigation animations) can crash the host app inside the vendor driver (`vulkan.adreno.so`) — a native fault that cannot be caught from Java or JS. Starting in 0.4.3 the native module: captures directly into a small (target-width) reused bitmap instead of a full-screen one (~20x smaller GPU readback per frame); reuses a single handler thread instead of spawning one per frame; allows only ONE capture in flight at a time (a busy driver makes the JS loop skip frames via `E_BUSY` rather than pile up readbacks); and keeps a crash-loop breaker — if the process previously died mid-capture twice, PixelCopy is permanently disabled on that device (`E_DISABLED`) and the SDK falls back to view-shot instead of crashing the app again. **Rebuild the Android app after upgrading** for these fixes to take effect.
 
 ## Publishing
 

package/android/src/main/java/com/akhilpulse/sessionreplay/SessionReplayPixelCopyModule.kt

@@ -1,6 +1,7 @@
 package com.akhilpulse.sessionreplay
 
 import android.app.Activity
+import android.content.Context
 import android.graphics.Bitmap
 import android.os.Build
 import android.os.Handler
@@ -25,6 +26,27 @@ import java.util.concurrent.atomic.AtomicBoolean
  *
  * Requires API 24 (Android 7.0). Falls back to view-shot in JS otherwise.
  *
+ * Efficiency / crash-hardening notes (v0.4.3):
+ *  - PixelCopy scales into the destination bitmap, so we capture DIRECTLY
+ *    into a small (targetWidth-sized) bitmap instead of a full-screen
+ *    ARGB_8888 one (~10 MB/frame at 1080p, 4 fps). This cuts the GPU
+ *    readback size ~20x, which both saves battery and dramatically narrows
+ *    the window in which a busy GPU driver (maps, nav animations) can fault.
+ *  - The destination bitmap and the HandlerThread are reused across frames
+ *    instead of being allocated/started/torn down 4x per second.
+ *  - Only ONE capture may be in flight at a time. If JS asks for a frame
+ *    while the previous PixelCopy is still queued in the driver (typical
+ *    when the GPU is saturated), we reject with E_BUSY and JS simply skips
+ *    that frame — queueing readbacks against a saturated Adreno driver is
+ *    the known crash scenario (native fault in vulkan.adreno.so, which
+ *    cannot be caught from Java/Kotlin).
+ *  - Crash-loop breaker: a SharedPreferences sentinel is set while a copy
+ *    is in flight and cleared when it settles. If the process died mid-copy
+ *    (i.e. the driver crashed the app), the next launch sees the sentinel,
+ *    increments a crash counter, and after MAX_DRIVER_CRASHES the module
+ *    permanently rejects with E_DISABLED on this device so JS uses the
+ *    safe view-shot fallback instead of crashing the host app again.
+ *
  * Note: Dialog windows (react-native `Modal`, react-native-modal, many
  * bottom-sheet libraries) live on a separate Window and are not included
  * in this capture. A future version will composite those in via reflection.
@@ -32,89 +54,211 @@ import java.util.concurrent.atomic.AtomicBoolean
 class SessionReplayPixelCopyModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
+  companion object {
+    private const val PREFS = "session_replay_pixelcopy"
+    private const val KEY_IN_FLIGHT = "capture_in_flight"
+    private const val KEY_DRIVER_CRASHES = "driver_crash_count"
+    private const val MAX_DRIVER_CRASHES = 2
+    private const val TIMEOUT_MS = 1200L
+  }
+
   override fun getName(): String = "SessionReplayPixelCopy"
 
+  private val inFlight = AtomicBoolean(false)
+
+  // Lazily-created, reused across frames. Never torn down per capture.
+  @Volatile private var handlerThread: HandlerThread? = null
+  @Volatile private var handler: Handler? = null
+
+  // Reused destination bitmap (small: targetWidth x scaled height).
+  // Guarded by bitmapLock — touched from the UI thread (obtain), the capture
+  // handler thread (timeout orphaning) and arbitrary threads (invalidate).
+  private val bitmapLock = Any()
+  private var reusableBitmap: Bitmap? = null
+
+  // Cached crash-history verdict (null = not checked yet this process).
+  @Volatile private var disabledOnThisDevice: Boolean? = null
+
+  private fun prefs() =
+      reactApplicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+  /**
+   * Returns true when PixelCopy must not be used on this device because a
+   * previous process died while a copy was in flight (native driver crash).
+   */
+  private fun isDisabledByCrashHistory(): Boolean {
+    disabledOnThisDevice?.let { return it }
+    synchronized(this) {
+      disabledOnThisDevice?.let { return it }
+      val p = prefs()
+      var crashes = p.getInt(KEY_DRIVER_CRASHES, 0)
+      if (p.getBoolean(KEY_IN_FLIGHT, false)) {
+        // Previous process died mid-capture — treat as a driver crash.
+        crashes += 1
+        p.edit()
+            .putInt(KEY_DRIVER_CRASHES, crashes)
+            .putBoolean(KEY_IN_FLIGHT, false)
+            .apply()
+      }
+      val disabled = crashes >= MAX_DRIVER_CRASHES
+      disabledOnThisDevice = disabled
+      return disabled
+    }
+  }
+
+  private fun captureHandler(): Handler {
+    handler?.let { return it }
+    synchronized(this) {
+      handler?.let { return it }
+      val t = HandlerThread("SessionReplayPixelCopy")
+      t.start()
+      handlerThread = t
+      val h = Handler(t.looper)
+      handler = h
+      return h
+    }
+  }
+
+  private fun obtainBitmap(w: Int, h: Int): Bitmap {
+    synchronized(bitmapLock) {
+      val existing = reusableBitmap
+      if (existing != null && !existing.isRecycled && existing.width == w && existing.height == h) {
+        return existing
+      }
+      existing?.recycle()
+      val fresh = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+      reusableBitmap = fresh
+      return fresh
+    }
+  }
+
+  /** Drop the cached bitmap WITHOUT recycling (a late driver write may still land in it). */
+  private fun orphanBitmap() {
+    synchronized(bitmapLock) { reusableBitmap = null }
+  }
+
+  private fun markInFlight(active: Boolean) {
+    try {
+      prefs().edit().putBoolean(KEY_IN_FLIGHT, active).apply()
+    } catch (_: Throwable) {}
+  }
+
   @ReactMethod
   fun capture(targetWidth: Double, quality: Double, promise: Promise) {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
       promise.reject("E_API", "PixelCopy requires Android 7.0+ (API 24)")
       return
     }
+    if (isDisabledByCrashHistory()) {
+      promise.reject(
+          "E_DISABLED",
+          "PixelCopy disabled on this device after previous GPU driver crashes")
+      return
+    }
+    // Single in-flight capture: if the driver is still working on the last
+    // readback (GPU busy — maps, animations), skip this frame instead of
+    // queueing more work against a saturated driver.
+    if (!inFlight.compareAndSet(false, true)) {
+      promise.reject("E_BUSY", "Previous capture still in flight")
+      return
+    }
+
     val activity: Activity? = currentActivity
     if (activity == null) {
+      inFlight.set(false)
       promise.reject("E_NO_ACTIVITY", "No current activity")
       return
     }
 
     activity.runOnUiThread {
       val settled = AtomicBoolean(false)
-      val handlerThread = HandlerThread("SessionReplayPixelCopy")
-      handlerThread.start()
-      val handler = Handler(handlerThread.looper)
+      val h = captureHandler()
 
-      // Safety net: if PixelCopy never invokes its callback (rare driver
-      // bug on some vendor ROMs), reject after 1.5s instead of leaving the
-      // JS promise pending forever and freezing the capture loop.
-      handler.postDelayed({
+      fun settle(block: () -> Unit) {
         if (settled.compareAndSet(false, true)) {
-          try { promise.reject("E_TIMEOUT", "PixelCopy timed out") } catch (_: Throwable) {}
-          handlerThread.quitSafely()
+          try {
+            block()
+          } catch (_: Throwable) {}
+          markInFlight(false)
+          inFlight.set(false)
+        }
+      }
+
+      // Safety net: if PixelCopy never invokes its callback (rare driver
+      // bug on some vendor ROMs), reject instead of leaving the JS promise
+      // pending forever and freezing the capture loop.
+      h.postDelayed({
+        settle {
+          // The driver may still write into the destination bitmap after a
+          // timeout — orphan it (without recycling) so the next capture
+          // allocates a fresh one instead of racing the late writer.
+          orphanBitmap()
+          promise.reject("E_TIMEOUT", "PixelCopy timed out")
         }
-      }, 1500)
+      }, TIMEOUT_MS)
 
       try {
         val window = activity.window
         val decor = window.decorView
         val srcW = decor.width
         val srcH = decor.height
-        if (srcW <= 0 || srcH <= 0) {
-          if (settled.compareAndSet(false, true)) {
-            promise.reject("E_NO_SIZE", "Decor view has zero size")
-            handlerThread.quitSafely()
-          }
+        if (srcW <= 0 || srcH <= 0 || !decor.isAttachedToWindow) {
+          settle { promise.reject("E_NO_SIZE", "Decor view not ready") }
           return@runOnUiThread
         }
-        val bitmap = Bitmap.createBitmap(srcW, srcH, Bitmap.Config.ARGB_8888)
+
+        // Capture directly at the downscaled size — PixelCopy scales the
+        // window contents to fit the destination bitmap, so there is no
+        // need for a full-resolution intermediate bitmap + scale pass.
+        val tw = targetWidth.toInt().coerceAtLeast(1).coerceAtMost(srcW)
+        val th = (srcH.toDouble() / srcW.toDouble() * tw).toInt().coerceAtLeast(1)
+        val bitmap = obtainBitmap(tw, th)
+
+        // Sentinel: if the process dies inside the driver during this copy,
+        // the next launch will see it and count a crash (see
+        // isDisabledByCrashHistory).
+        markInFlight(true)
 
         PixelCopy.request(
             window,
             bitmap,
             { result ->
-              if (!settled.compareAndSet(false, true)) return@request
-              try {
+              settle {
                 if (result == PixelCopy.SUCCESS) {
-                  val tw = targetWidth.toInt().coerceAtLeast(1)
-                  val scaled = if (tw < srcW) {
-                    val th = (srcH.toDouble() / srcW.toDouble() * tw).toInt().coerceAtLeast(1)
-                    Bitmap.createScaledBitmap(bitmap, tw, th, true)
-                  } else bitmap
-
                   val q = (quality * 100).toInt().coerceIn(1, 100)
                   val baos = ByteArrayOutputStream()
-                  scaled.compress(Bitmap.CompressFormat.JPEG, q, baos)
-                  if (scaled !== bitmap) scaled.recycle()
-                  bitmap.recycle()
-
+                  bitmap.compress(Bitmap.CompressFormat.JPEG, q, baos)
                   val b64 = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP)
                   promise.resolve(b64)
                 } else {
-                  bitmap.recycle()
                   promise.reject("E_PIXELCOPY", "PixelCopy failed: $result")
                 }
-              } catch (e: Throwable) {
-                promise.reject("E_INNER", e)
-              } finally {
-                handlerThread.quitSafely()
               }
             },
-            handler
+            h
         )
       } catch (e: Throwable) {
-        if (settled.compareAndSet(false, true)) {
-          promise.reject("E_OUTER", e)
-          handlerThread.quitSafely()
-        }
+        settle { promise.reject("E_OUTER", e) }
       }
     }
   }
+
+  override fun invalidate() {
+    // Called when the React instance is torn down — release resources.
+    // Clear the crash sentinel: a teardown mid-capture is a CLEAN shutdown,
+    // not a driver crash, and must not count toward the crash-loop breaker.
+    if (inFlight.getAndSet(false)) {
+      markInFlight(false)
+    }
+    try {
+      handlerThread?.quitSafely()
+    } catch (_: Throwable) {}
+    handlerThread = null
+    handler = null
+    synchronized(bitmapLock) {
+      // Don't recycle — a late driver write could still land in it.
+      reusableBitmap = null
+    }
+    super.invalidate()
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akhilpulse/samadhaan-session-replay",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "React Native SDK for Samadhaan Guided Support — session recording, live remote screen-share, take-control, guided-tour overlays, and Shake-to-Assist AI voice guide.",
   "main": "src/index.ts",
   "module": "src/index.ts",

package/src/SessionReplayProvider.tsx

@@ -50,10 +50,11 @@ import {
 type PixelCopyNative = { capture: (targetWidth: number, quality: number) => Promise<string> };
 const SessionReplayPixelCopy: PixelCopyNative | undefined =
   Platform.OS === "android" ? (NativeModules as any).SessionReplayPixelCopy : undefined;
-let pixelCopyDisabled = false; // turned true after a runtime failure to avoid retrying every frame
+let pixelCopyDisabled = false; // turned true after repeated runtime failures to avoid retrying every frame
+let pixelCopyFailStreak = 0; // consecutive non-busy failures; resets on success
 
 const STORAGE_KEY = "@akhilpulse/samadhaan-session-replay/sessionId";
-const SDK_VERSION = "0.4.2";
+const SDK_VERSION = "0.4.3";
 
 // ---- Module-level session singleton --------------------------------------
 // Multiple SessionReplayProvider mounts (intentional or via React StrictMode's
@@ -392,15 +393,32 @@ export function SessionReplayProvider({ config, children }: { config: Config; ch
             result: "base64" as const,
             width: 360,
           };
-          let uri: string;
+          let uri: string | null = null;
           if (Platform.OS === "android") {
             if (SessionReplayPixelCopy && !pixelCopyDisabled) {
               try {
                 uri = await SessionReplayPixelCopy.capture(360, 0.25);
-              } catch (err) {
-                if (__DEV__) console.warn("[session-replay] PixelCopy failed, falling back to view-shot:", err);
-                pixelCopyDisabled = true;
-                uri = await captureScreen(captureOpts);
+                pixelCopyFailStreak = 0;
+              } catch (err: any) {
+                const code = err?.code;
+                if (code === "E_BUSY") {
+                  // Previous capture still in flight — the GPU is saturated
+                  // (maps, nav animations). Skip this frame entirely rather
+                  // than piling more readback work onto a busy driver.
+                  uri = null;
+                } else {
+                  pixelCopyFailStreak++;
+                  if (code === "E_DISABLED" || code === "E_API" || pixelCopyFailStreak >= 3) {
+                    // Native module says never use PixelCopy on this device
+                    // (previous GPU driver crashes / API too old), or it has
+                    // failed repeatedly — stop trying.
+                    if (__DEV__) console.warn("[session-replay] PixelCopy disabled, using view-shot:", err);
+                    pixelCopyDisabled = true;
+                  } else if (__DEV__) {
+                    console.warn("[session-replay] PixelCopy failed, falling back to view-shot for this frame:", err);
+                  }
+                  uri = await captureScreen(captureOpts);
+                }
               }
             } else {
               uri = await captureScreen(captureOpts);
@@ -408,6 +426,12 @@ export function SessionReplayProvider({ config, children }: { config: Config; ch
           } else {
             uri = await captureRef(ref as any, captureOpts);
           }
+          if (!uri) {
+            // Frame intentionally skipped (GPU busy) — try again next tick.
+            const elapsedSkip = Date.now() - startedAt;
+            setTimeout(tick, Math.max(0, liveTargetMs - elapsedSkip));
+            return;
+          }
           const blob = base64ToUint8Array(uri);
           // Stream binary over WS — no REST upload in the hot path.
           if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {