@akhilpulse/samadhaan-session-replay 0.3.2 → 0.3.3

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

@@ -2,41 +2,32 @@ package com.akhilpulse.sessionreplay
 
 import android.app.Activity
 import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Paint
-import android.graphics.PorterDuff
 import android.os.Build
 import android.os.Handler
 import android.os.HandlerThread
 import android.util.Base64
 import android.view.PixelCopy
-import android.view.View
-import android.view.ViewGroup
-import android.view.Window
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import java.io.ByteArrayOutputStream
-import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicBoolean
 
 /**
- * Captures the full visible screen by enumerating EVERY active Window the
- * app currently has on screen (the Activity window plus any Dialog windows
- * — react-native `Modal`, react-native-modal, react-native-paper Dialog,
- * many bottom-sheet libraries, etc. all render into separate Dialog
- * windows on Android), running a PixelCopy on each, and compositing them
- * onto a single bitmap in the same z-order they're drawn.
- *
- * PixelCopy reads the actual on-screen pixels, so hardware-accelerated
- * layers (views with `elevation` / `zIndex`, native SurfaceViews like
- * react-native-maps, FABs with shadows) are all included.
+ * Captures the Activity's window via Android PixelCopy, which reads the
+ * actual on-screen pixels (including hardware-accelerated layers like views
+ * with `elevation` / `zIndex`, FABs, native SurfaceViews/MapViews).
  *
  * Returns a base64-encoded JPEG (no `data:` prefix) — same shape as
  * react-native-view-shot's `result: "base64"` so the JS side can use it
  * interchangeably.
  *
  * Requires API 24 (Android 7.0). Falls back to view-shot in JS otherwise.
+ *
+ * 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.
  */
 class SessionReplayPixelCopyModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
@@ -56,226 +47,74 @@ class SessionReplayPixelCopyModule(reactContext: ReactApplicationContext) :
     }
 
     activity.runOnUiThread {
-      try {
-        val activityWindow = activity.window
-        val activityDecor = activityWindow.decorView
-        val srcW = activityDecor.width
-        val srcH = activityDecor.height
-        if (srcW <= 0 || srcH <= 0) {
-          promise.reject("E_NO_SIZE", "Decor view has zero size")
-          return@runOnUiThread
+      val settled = AtomicBoolean(false)
+      val handlerThread = HandlerThread("SessionReplayPixelCopy")
+      handlerThread.start()
+      val handler = Handler(handlerThread.looper)
+
+      // 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({
+        if (settled.compareAndSet(false, true)) {
+          try { promise.reject("E_TIMEOUT", "PixelCopy timed out") } catch (_: Throwable) {}
+          handlerThread.quitSafely()
         }
+      }, 1500)
 
-        // Discover every active Window via WindowManagerGlobal reflection.
-        // The list is returned in the order Android added them, which is
-        // bottom-to-top z-order (Activity window first, then Dialogs / Toasts
-        // on top), so we composite in that same order.
-        val windows = collectWindows(activityWindow)
-
-        val composite = Bitmap.createBitmap(srcW, srcH, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(composite)
-        // Pre-fill black so any sub-window that fails capture doesn't show
-        // garbage memory.
-        canvas.drawColor(0xFF000000.toInt())
-
-        val handlerThread = HandlerThread("SessionReplayPixelCopy")
-        handlerThread.start()
-        val handler = Handler(handlerThread.looper)
-
-        val remaining = AtomicInteger(windows.size)
-        val results = arrayOfNulls<Bitmap>(windows.size)
-        val locations = Array(windows.size) { intArrayOf(0, 0) }
-
-        if (windows.isEmpty()) {
-          // Should never happen — at least the Activity window exists — but
-          // bail safely instead of hanging.
-          finish(composite, srcW, srcH, targetWidth, quality, promise, handlerThread)
-          return@runOnUiThread
-        }
-
-        for ((index, win) in windows.withIndex()) {
-          val decor: View = win.decorView
-          val w = decor.width
-          val h = decor.height
-          if (w <= 0 || h <= 0) {
-            // Skip zero-size windows (e.g. just-dismissed dialogs).
-            results[index] = null
-            if (remaining.decrementAndGet() == 0) {
-              compositeAll(canvas, windows, results, locations)
-              finish(composite, srcW, srcH, targetWidth, quality, promise, handlerThread)
-            }
-            continue
-          }
-          // Capture this window's screen-space origin so we can position it
-          // correctly on the composite (Dialog windows are usually centered
-          // or anchored, not at 0,0).
-          decor.getLocationOnScreen(locations[index])
-
-          val sub = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
-          try {
-            PixelCopy.request(
-                win,
-                sub,
-                { result ->
-                  if (result == PixelCopy.SUCCESS) {
-                    results[index] = sub
-                  } else {
-                    sub.recycle()
-                    results[index] = null
-                  }
-                  if (remaining.decrementAndGet() == 0) {
-                    compositeAll(canvas, windows, results, locations)
-                    finish(composite, srcW, srcH, targetWidth, quality, promise, handlerThread)
-                  }
-                },
-                handler
-            )
-          } catch (e: Throwable) {
-            // Some windows (e.g. SurfaceView-only windows, secure windows)
-            // may reject PixelCopy synchronously. Skip them.
-            sub.recycle()
-            results[index] = null
-            if (remaining.decrementAndGet() == 0) {
-              compositeAll(canvas, windows, results, locations)
-              finish(composite, srcW, srcH, targetWidth, quality, promise, handlerThread)
-            }
+      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()
           }
+          return@runOnUiThread
         }
+        val bitmap = Bitmap.createBitmap(srcW, srcH, Bitmap.Config.ARGB_8888)
+
+        PixelCopy.request(
+            window,
+            bitmap,
+            { result ->
+              if (!settled.compareAndSet(false, true)) return@request
+              try {
+                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()
+
+                  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
+        )
       } catch (e: Throwable) {
-        promise.reject("E_OUTER", e)
-      }
-    }
-  }
-
-  /**
-   * Reflects into android.view.WindowManagerGlobal to obtain every Window
-   * the app currently has attached. Falls back to just the Activity window
-   * if reflection fails (newer Android versions or vendor-modified ROMs).
-   */
-  private fun collectWindows(activityWindow: Window): List<Window> {
-    val list = mutableListOf<Window>()
-    try {
-      val wmgClass = Class.forName("android.view.WindowManagerGlobal")
-      val getInstance = wmgClass.getMethod("getInstance")
-      val wmg = getInstance.invoke(null)
-
-      // mViews: ArrayList<View>  (the decor view of each window, in z-order)
-      val viewsField = wmgClass.getDeclaredField("mViews").apply { isAccessible = true }
-      @Suppress("UNCHECKED_CAST")
-      val views = viewsField.get(wmg) as List<View>
-
-      // mParams: ArrayList<WindowManager.LayoutParams> — same length as mViews.
-      // (Reserved for future filtering by window type if needed.)
-
-      for (v in views) {
-        // Skip views that aren't currently attached / visible.
-        if (!v.isAttachedToWindow) continue
-        if (v.visibility != View.VISIBLE) continue
-        // Skip system overlays from other packages (shouldn't happen since
-        // mViews is per-process, but guard anyway).
-        val ctx = v.context ?: continue
-        if (ctx.packageName != activityWindow.context.packageName) continue
-
-        // The Window object itself isn't directly on the View, but PixelCopy
-        // accepts a Window — and we can synthesize a wrapper from the
-        // ViewRootImpl's Surface using the alternative PixelCopy.request
-        // overload. Easier path: walk up the view tree to find the
-        // associated Window via the context (Activity / Dialog).
-        val win = findWindowForView(v, activityWindow)
-        if (win != null && !list.contains(win)) {
-          list.add(win)
-        }
-      }
-    } catch (_: Throwable) {
-      // Reflection failed — at minimum capture the activity window.
-    }
-    if (list.isEmpty()) list.add(activityWindow)
-    return list
-  }
-
-  /**
-   * Tries to resolve the Window that owns a given decor view. Activity
-   * windows are easy (context is the Activity). Dialog windows store their
-   * Window via the view's parent context chain.
-   */
-  private fun findWindowForView(view: View, activityWindow: Window): Window? {
-    // If this view IS the activity's decor, return that window.
-    if (view === activityWindow.decorView) return activityWindow
-
-    // Try unwrapping the context chain to find a Dialog or Activity.
-    var ctx = view.context
-    var depth = 0
-    while (ctx != null && depth < 10) {
-      when (ctx) {
-        is Activity -> return ctx.window
-        else -> {
-          // android.view.ContextThemeWrapper / Dialog's inner context: try
-          // reflection to get a `getWindow()` if present.
-          try {
-            val m = ctx.javaClass.getMethod("getWindow")
-            val w = m.invoke(ctx)
-            if (w is Window) return w
-          } catch (_: Throwable) {
-            // Walk to the base context.
-          }
-          val baseField = try { ctx.javaClass.getMethod("getBaseContext") } catch (_: Throwable) { null }
-          ctx = try { baseField?.invoke(ctx) as? android.content.Context } catch (_: Throwable) { null }
+        if (settled.compareAndSet(false, true)) {
+          promise.reject("E_OUTER", e)
+          handlerThread.quitSafely()
         }
       }
-      depth++
-    }
-    return null
-  }
-
-  private fun compositeAll(
-      canvas: Canvas,
-      windows: List<Window>,
-      results: Array<Bitmap?>,
-      locations: Array<IntArray>
-  ) {
-    val activityOrigin = intArrayOf(0, 0)
-    if (windows.isNotEmpty()) {
-      windows[0].decorView.getLocationOnScreen(activityOrigin)
-    }
-    for (i in results.indices) {
-      val bmp = results[i] ?: continue
-      // Translate window screen-space origin into composite-space (relative
-      // to the activity decor's top-left).
-      val left = (locations[i][0] - activityOrigin[0]).toFloat()
-      val top = (locations[i][1] - activityOrigin[1]).toFloat()
-      canvas.drawBitmap(bmp, left, top, null)
-      bmp.recycle()
-    }
-  }
-
-  private fun finish(
-      composite: Bitmap,
-      srcW: Int,
-      srcH: Int,
-      targetWidth: Double,
-      quality: Double,
-      promise: Promise,
-      handlerThread: HandlerThread
-  ) {
-    try {
-      val tw = targetWidth.toInt().coerceAtLeast(1)
-      val scaled = if (tw < srcW) {
-        val th = (srcH.toDouble() / srcW.toDouble() * tw).toInt().coerceAtLeast(1)
-        Bitmap.createScaledBitmap(composite, tw, th, true)
-      } else composite
-
-      val q = (quality * 100).toInt().coerceIn(1, 100)
-      val baos = ByteArrayOutputStream()
-      scaled.compress(Bitmap.CompressFormat.JPEG, q, baos)
-      if (scaled !== composite) scaled.recycle()
-      composite.recycle()
-
-      val b64 = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP)
-      promise.resolve(b64)
-    } catch (e: Throwable) {
-      promise.reject("E_FINISH", e)
-    } finally {
-      handlerThread.quitSafely()
     }
   }
 }

package/package.json

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