feat: recursive mask collection (#308)

## Summary

1. Refactored to use recursive collection to allow to gather Matrix
transformations and hierarchical privacy options
2. Use AbstractComposeView as the base for compose to catch non-standard
ComposeViews
3. Filter out AndroidComposeViews, they are always internal
4. 0 warning state of SR code
<img width="1092" height="905" alt="image"
src="https://github.com/user-attachments/assets/9a729721-4ed5-46c8-bbba-2b7834ac57ad"
/>



## How did you test this change?

<!--
Frontend - Leave a screencast or a screenshot to visually describe the
changes.
-->

## Are there any deployment considerations?

<!--
 Backend - Do we need to consider migrations or backfilling data?
-->

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Switches to a recursive mask collection using a new Mask model,
updates capture to draw masks across windows, and improves window
inspection on Q+.
> 
> - **Masking**:
> - Introduces `Mask` model and new recursive `MaskCollector` that
traverses native and Compose (`AbstractComposeView`) hierarchies;
filters internal `AndroidComposeView`.
> - Updates `ComposeMaskTarget`/`NativeMaskTarget` to return `Mask`;
adds stronger password detection via `InputType` checks.
> - Removes `SensitiveAreasCollector` and `maskRect` API in favor of
`mask()`.
> - **Capture**:
> - `CaptureSource` now collects `Mask`s and draws them; bases capture
on lowest visible window and composites additional windows with
translations.
> - Refactors bitmap creation (`createBitmap`), adds `@RequiresApi` to
`pixelCopy`, simplifies `canvasDraw`.
> - **Window inspection**:
> - `WindowInspector` uses Q+ `WindowInspector.getGlobalWindowViews()`
and a new `locationOnScreen()` util for coordinates; cleans up root view
reflection.
> - **Utils**:
>   - Adds `View.locationOnScreen()` extension.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
1180d8b. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: abelonogov-ld

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/capture/CaptureSource.kt

@@ -1,6 +1,5 @@
 package com.launchdarkly.observability.replay.capture
 
-import android.annotation.SuppressLint
 import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
@@ -16,10 +15,11 @@ import android.view.View
 import android.view.Window
 import android.view.WindowManager.LayoutParams.TYPE_APPLICATION
 import android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION
+import androidx.annotation.RequiresApi
 import com.launchdarkly.logging.LDLogger
 import com.launchdarkly.observability.coroutines.DispatcherProviderHolder
 import com.launchdarkly.observability.replay.masking.MaskMatcher
-import com.launchdarkly.observability.replay.masking.SensitiveAreasCollector
+import com.launchdarkly.observability.replay.masking.MaskCollector
 import io.opentelemetry.android.session.SessionManager
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -29,11 +29,12 @@ import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
 import java.io.ByteArrayOutputStream
 import kotlin.coroutines.resume
-import androidx.compose.ui.geometry.Rect as ComposeRect
 import androidx.core.graphics.withTranslation
+import com.launchdarkly.observability.replay.masking.Mask
+import androidx.core.graphics.createBitmap
 
 /**
- * A source of [CaptureEvent]s taken from the most recently resumed [Activity]s window. Captures
+ * A source of [CaptureEvent]s taken from the lowest visible window. Captures
  * are emitted on the [captureFlow] property of this class.
  *
  * @param sessionManager Used to get current session for tagging [CaptureEvent] with session id
@@ -47,13 +48,13 @@ class CaptureSource(
     data class CaptureResult(
         val windowEntry: WindowEntry,
         val bitmap: Bitmap,
-        val masks: List<ComposeRect>
+        val masks: List<Mask>
     )
 
     private val _captureEventFlow = MutableSharedFlow<CaptureEvent>()
     val captureFlow: SharedFlow<CaptureEvent> = _captureEventFlow.asSharedFlow()
     private val windowInspector = WindowInspector(logger)
-    private val sensitiveAreasCollector = SensitiveAreasCollector(logger)
+    private val maskCollector = MaskCollector(logger)
     private val maskPaint = Paint().apply {
         color = Color.GRAY
         style = Paint.Style.FILL
@@ -78,7 +79,7 @@ class CaptureSource(
     private suspend fun doCapture(): CaptureEvent? =
         withContext(DispatcherProviderHolder.current.main) {
             // Synchronize with UI rendering frame
-            suspendCancellableCoroutine<Unit> { continuation ->
+            suspendCancellableCoroutine { continuation ->
                 Choreographer.getInstance().postFrameCallback {
                     if (continuation.isActive) {
                         continuation.resume(Unit)
@@ -167,8 +168,8 @@ class CaptureSource(
 
     private suspend fun captureViewResult(windowEntry: WindowEntry): CaptureResult? {
         val bitmap = captureViewBitmap(windowEntry) ?: return null
-        val sensitiveComposeRects = sensitiveAreasCollector.collectFromActivity(windowEntry.rootView, maskMatchers)
-        return CaptureResult(windowEntry, bitmap, sensitiveComposeRects)
+        val masks = maskCollector.collectMasks(windowEntry.rootView, maskMatchers)
+        return CaptureResult(windowEntry, bitmap, masks)
     }
 
     private suspend fun captureViewBitmap(windowEntry: WindowEntry): Bitmap? {
@@ -187,21 +188,16 @@ class CaptureSource(
         return withContext(Dispatchers.Main.immediate) {
             if (!view.isAttachedToWindow || !view.isShown) return@withContext null
 
-            return@withContext canvasDraw(view, windowEntry.rect())
+            return@withContext canvasDraw(view)
         }
     }
-
-    @SuppressLint("NewApi")
+    @RequiresApi(Build.VERSION_CODES.O)
     private suspend fun pixelCopy(
         window: Window,
         view: View,
         rect: Rect,
     ): Bitmap? {
-        val bitmap = Bitmap.createBitmap(
-            view.width,
-            view.height,
-            Bitmap.Config.ARGB_8888
-        )
+        val bitmap = createBitmap(view.width, view.height)
 
         return suspendCancellableCoroutine { continuation ->
             val handler = Handler(Looper.getMainLooper())
@@ -228,14 +224,9 @@ class CaptureSource(
     }
 
     private fun canvasDraw(
-        view: View,
-        rect: Rect,
-    ): Bitmap? {
-        val bitmap = Bitmap.createBitmap(
-            view.width,
-            view.height,
-            Bitmap.Config.ARGB_8888
-        )
+        view: View
+    ): Bitmap {
+        val bitmap = createBitmap(view.width, view.height)
 
         val canvas = Canvas(bitmap)
         view.draw(canvas)
@@ -287,17 +278,17 @@ class CaptureSource(
      * Applies masking rectangles to the provided [canvas] using the provided [masks].
      *
      * @param canvas The canvas to mask
-     * @param masks rects that will be masked
+     * @param masks areas that will be masked
      */
-    private fun drawMasks(canvas: Canvas, masks: List<ComposeRect>) {
+    private fun drawMasks(canvas: Canvas, masks: List<Mask>) {
         masks.forEach { mask ->
-            val androidRect = Rect(
-                mask.left.toInt(),
-                mask.top.toInt(),
-                mask.right.toInt(),
-                mask.bottom.toInt()
+            val integerRect = Rect(
+                mask.rect.left.toInt(),
+                mask.rect.top.toInt(),
+                mask.rect.right.toInt(),
+                mask.rect.bottom.toInt()
             )
-            canvas.drawRect(androidRect, maskPaint)
+            canvas.drawRect(integerRect, maskPaint)
         }
     }
 }

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/capture/WindowEntry.kt

@@ -1,7 +1,6 @@
 package com.launchdarkly.observability.replay.capture
 
 import android.graphics.Rect
-import android.os.Build
 import android.view.View
 import android.view.WindowManager
 import android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/capture/WindowInspector.kt

@@ -1,20 +1,27 @@
 package com.launchdarkly.observability.replay.capture
 
+import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.content.ContextWrapper
 import android.graphics.Rect
+import android.os.Build
 import android.view.View
 import android.view.Window
 import android.view.WindowManager
 import com.launchdarkly.logging.LDLogger
+import com.launchdarkly.observability.replay.utils.locationOnScreen
 import kotlin.jvm.javaClass
 
 class WindowInspector(private val logger: LDLogger) {
 
     fun appWindows(appContext: Context? = null): List<WindowEntry> {
         val appUid = appContext?.applicationInfo?.uid
-        val views = getRootViews() ?: return emptyList()
+        val views: List<View> = if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q){
+            android.view.inspector.WindowInspector.getGlobalWindowViews().map { it.rootView }
+        } else {
+            getRootViews()
+        }
         return views.mapNotNull { view ->
             if (appUid != null && view.context.applicationInfo?.uid != appUid) return@mapNotNull null
             if (!view.isAttachedToWindow || !view.isShown) return@mapNotNull null
@@ -24,8 +31,7 @@ class WindowInspector(private val logger: LDLogger) {
             if (!view.getGlobalVisibleRect(visibleRect)) return@mapNotNull null
             if (visibleRect.width() == 0 || visibleRect.height() == 0) return@mapNotNull null
 
-            val loc = IntArray(2)
-            view.getLocationOnScreen(loc)
+            val (screenX, screenY) = view.locationOnScreen()
 
             val layoutParams = view.layoutParams as? WindowManager.LayoutParams
             val wmType = layoutParams?.type ?: 0
@@ -36,8 +42,8 @@ class WindowInspector(private val logger: LDLogger) {
                 layoutParams = layoutParams,
                 width = view.width,
                 height = view.height,
-                screenLeft = loc[0],
-                screenTop = loc[1]
+                screenLeft = screenX.toInt(),
+                screenTop = screenY.toInt()
             )
         }
     }
@@ -50,6 +56,7 @@ class WindowInspector(private val logger: LDLogger) {
      * 2) Reflection to call getWindow() if present
      * 3) Context unwrap to Activity and return activity.window (best-effort fallback)
      */
+    @SuppressLint("PrivateApi")
     fun findWindow(rootView: View): Window? {
         // 1) Try to read a private field "mWindow" (present on DecorView/PopupDecorView)
         try {
@@ -100,6 +107,7 @@ class WindowInspector(private val logger: LDLogger) {
         return null
     }
 
+    @SuppressLint("PrivateApi")
     fun getRootViews(): List<View> {
         return try {
             val wmgClass = Class.forName("android.view.WindowManagerGlobal")
@@ -111,8 +119,7 @@ class WindowInspector(private val logger: LDLogger) {
             }.getOrNull()
 
             if (getRootViewsMethod != null) {
-                val result = getRootViewsMethod.invoke(instance)
-                return when (result) {
+                return when (val result = getRootViewsMethod.invoke(instance)) {
                     is Array<*> -> result.filterIsInstance<View>()
                     is List<*> -> result.filterIsInstance<View>()
                     else -> emptyList()
@@ -125,8 +132,7 @@ class WindowInspector(private val logger: LDLogger) {
             }.getOrNull()
 
             if (mViewsField != null) {
-                val result = mViewsField.get(instance)
-                return when (result) {
+                return when (val result = mViewsField.get(instance)) {
                     is Array<*> -> result.filterIsInstance<View>()
                     is List<*> -> result.filterIsInstance<View>()
                     else -> emptyList()

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/masking/ComposeMaskTarget.kt

@@ -1,7 +1,8 @@
 package com.launchdarkly.observability.replay.masking
 
 import android.view.View
-import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.graphics.toAndroidRectF
+import androidx.compose.ui.platform.AbstractComposeView
 import androidx.compose.ui.semantics.SemanticsNode
 import androidx.compose.ui.semantics.SemanticsOwner
 import androidx.compose.ui.semantics.SemanticsConfiguration
@@ -23,7 +24,7 @@ data class ComposeMaskTarget(
     val boundsInWindow: MaskRect,
 ) : MaskTarget {
     companion object {
-        fun from(composeView: ComposeView, logger: LDLogger): ComposeMaskTarget? {
+        fun from(composeView: AbstractComposeView, logger: LDLogger): ComposeMaskTarget? {
             val root = getRootSemanticsNode(composeView, logger) ?: return null
             return ComposeMaskTarget(
                 view = composeView,
@@ -37,7 +38,7 @@ data class ComposeMaskTarget(
          * Gets the SemanticsOwner from a ComposeView using reflection. This is necessary because
          * AndroidComposeView and semanticsOwner are not publicly exposed.
          */
-        private fun getRootSemanticsNode(composeView: ComposeView, logger: LDLogger): SemanticsNode? {
+        private fun getRootSemanticsNode(composeView: AbstractComposeView, logger: LDLogger): SemanticsNode? {
             return try {
                 if (composeView.isNotEmpty()) {
                     val androidComposeView = composeView.getChildAt(0)
@@ -72,8 +73,12 @@ data class ComposeMaskTarget(
         return config.contains(SemanticsProperties.Text)
     }
 
-    override fun maskRect(): MaskRect? {
-        return boundsInWindow
+    override fun mask(): Mask? {
+        val rect = boundsInWindow.toAndroidRectF()
+        if (rect.width() <= 0f || rect.height() <= 0f) {
+            return null
+        }
+        return Mask(boundsInWindow.toAndroidRectF(), view.id)
     }
 
     override fun hasLDMask(): Boolean {

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/replay/masking/Mask.kt

@@ -0,0 +1,29 @@
+package com.launchdarkly.observability.replay.masking
+import android.graphics.RectF
+import androidx.compose.ui.graphics.Matrix
+
+data class Mask(
+    val rect: RectF,
+    val viewId: Int,
+    val points: FloatArray? = null,
+    val matrix: Matrix? = null
+){
+    // Implemented to suppress warning
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is Mask) return false
+        return rect == other.rect &&
+                viewId == other.viewId &&
+                points.contentEquals(other.points) &&
+                matrix == other.matrix
+    }
+
+    // Implemented to suppress warning
+    override fun hashCode(): Int {
+        var result = rect.hashCode()
+        result = 31 * result + viewId
+        result = 31 * result + points.contentHashCode()
+        result = 31 * result + (matrix?.hashCode() ?: 0)
+        return result
+    }
+}