@akhilpulse/samadhaan-session-replay 0.3.0 → 0.3.1

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

@@ -2,21 +2,35 @@ 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
 
 /**
- * Captures the Activity's window via Android PixelCopy, which reads the
- * actual on-screen pixels (including hardware-accelerated layers like views
- * with `elevation` / `zIndex`, modals, FABs, native SurfaceViews/MapViews).
+ * 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.
  *
  * 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
@@ -43,55 +57,225 @@ class SessionReplayPixelCopyModule(reactContext: ReactApplicationContext) :
 
     activity.runOnUiThread {
       try {
-        val window = activity.window
-        val decor = window.decorView
-        val srcW = decor.width
-        val srcH = decor.height
+        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 bitmap = Bitmap.createBitmap(srcW, srcH, Bitmap.Config.ARGB_8888)
+
+        // 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)
 
-        PixelCopy.request(
-            window,
-            bitmap,
-            { result ->
-              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
-        )
+        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)
+            }
+          }
+        }
       } 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 }
+        }
+      }
+      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.0",
+  "version": "0.3.1",
   "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",