@buoy-gg/bug-links 0.0.0-stage → 7.0.81

package/android/src/main/java/gg/buoy/buglinks/frames/FrameWalker.kt

@@ -0,0 +1,181 @@
+// What to box in a frame (research/bug-links-2026-10/media/SPEC.md, H rules).
+// Runs on the main thread. It never throws: anything it can't finish is a
+// reason, and the frame is dropped (H2).
+package gg.buoy.buglinks.frames
+
+import android.graphics.Matrix
+import android.graphics.RectF
+import android.os.SystemClock
+import android.text.InputType
+import android.text.method.PasswordTransformationMethod
+import android.view.SurfaceView
+import android.view.TextureView
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import android.widget.EditText
+import android.widget.ImageView
+import android.widget.TextView
+
+data class MaskSettings(var text: Boolean = true, var images: Boolean = true, var inputs: Boolean = true)
+
+/** One root to walk: a window's root view and where it sits in the frame, in px. */
+class WalkRoot(val view: View, val dx: Float, val dy: Float)
+
+class Walk {
+  /** Every part to box, by view, in frame points. */
+  val parts = HashMap<View, RectF>()
+  var buoyOpen = false
+  var failed: String? = null
+}
+
+enum class PartKind { NONE, TEXT, INPUT, SECURE, IMAGE, WEB, OPAQUE }
+
+object FrameWalker {
+  val buoyOpenIds = setOf("dial-devtools-root", "buoy-tool-host")
+  const val BUOY_ROOT = "floating-devtools-root"
+  const val MASK = "buoy-mask"
+  const val UNMASK = "buoy-unmask"
+  private const val GROW = 2f // H10
+
+  private class Item(val view: View, val root: WalkRoot, val unmask: Boolean, val inBuoy: Boolean)
+
+  fun walk(roots: List<WalkRoot>, frameW: Float, frameH: Float, density: Float, settings: MaskSettings, budgetMs: Long): Walk {
+    val out = Walk()
+    val start = SystemClock.uptimeMillis()
+    val stack = ArrayList<Item>()
+    for (r in roots.asReversed()) stack.add(Item(r.view, r, unmask = false, inBuoy = false))
+    val screenArea = frameW * frameH
+    var visited = 0
+    while (stack.isNotEmpty()) {
+      val item = stack.removeAt(stack.size - 1)
+      visited++
+      if (visited and 127 == 0 && SystemClock.uptimeMillis() - start > budgetMs) {
+        out.failed = "the screen has too many views to check in time"
+        return out
+      }
+      val v = item.view
+      if (v.visibility != View.VISIBLE || v.alpha <= 0f) continue
+
+      val id = nativeId(v) ?: sentryMarker(v)
+      var unmask = item.unmask
+      var inBuoy = item.inBuoy
+      if (id != null) {
+        if (id in buoyOpenIds) {
+          if (rect(v, item.root, frameW, frameH, density) != null) out.buoyOpen = true
+          continue
+        }
+        if (id == BUOY_ROOT) inBuoy = true
+        if (id == UNMASK) unmask = true
+      }
+
+      val kind = classify(v)
+      val box = when {
+        kind == PartKind.SECURE -> true // H5
+        inBuoy -> {
+          val r = rect(v, item.root, frameW, frameH, density)
+          r != null && r.width() * r.height() < screenArea * 0.6f && hasContent(v) // F5
+        }
+        id == MASK -> true // H6, H8
+        kind == PartKind.TEXT -> settings.text && !unmask
+        kind == PartKind.INPUT -> settings.inputs && !unmask
+        kind == PartKind.IMAGE -> settings.images && !unmask
+        kind == PartKind.WEB || kind == PartKind.OPAQUE -> !unmask // H5a
+        else -> false
+      }
+      if (box) rect(v, item.root, frameW, frameH, density)?.let { out.parts[v] = it }
+      // H12: only skip children a box clips. Inputs are walked for secure fields.
+      if (box && clips(v) && kind != PartKind.INPUT) continue
+      if (v is ViewGroup) {
+        for (i in v.childCount - 1 downTo 0) {
+          val c = v.getChildAt(i) ?: continue
+          stack.add(Item(c, item.root, unmask, inBuoy))
+        }
+      }
+    }
+    return out
+  }
+
+  fun nativeId(v: View): String? = v.getTag(com.facebook.react.R.id.view_tag_native_id) as? String
+
+  fun testId(v: View): String? = v.getTag(com.facebook.react.R.id.react_test_id) as? String
+
+  /**
+   * Sentry's <Sentry.Mask> and <Sentry.Unmask> count as ours, so an app that
+   * already marked its private parts for Sentry is covered here too.
+   */
+  private fun sentryMarker(v: View): String? = when (v.javaClass.simpleName) {
+    "RNSentryReplayMask" -> MASK
+    "RNSentryReplayUnmask" -> UNMASK
+    else -> null
+  }
+
+  fun classify(v: View): PartKind {
+    if (v is WebView) return PartKind.WEB
+    if (v is TextView) {
+      if (isSecret(v)) return PartKind.SECURE
+      return if (v is EditText) PartKind.INPUT else PartKind.TEXT
+    }
+    if (v is ImageView) return if (v.drawable == null) PartKind.NONE else PartKind.IMAGE
+    if (v is SurfaceView || v is TextureView) return PartKind.OPAQUE
+    val name = v.javaClass.name
+    if (name.contains("Secure")) return PartKind.SECURE
+    if (name.contains("TextInput") || name.contains("EditText")) return PartKind.INPUT
+    if (name.contains("WebView")) return PartKind.WEB
+    if (name.contains("PdfView") || name.contains("PDFView")) return PartKind.OPAQUE
+    for (w in listOf("Compose", "Skia", "MapView", "Video", "Player", "Camera", "Preview", "GLView", "Canvas", "Chart")) {
+      if (name.contains(w)) return PartKind.OPAQUE
+    }
+    if (name.contains("Image") || name.contains("Svg") || name.contains("SVG") || name.contains("Lottie") || name.contains("Rive")) return PartKind.IMAGE
+    if (name.contains("Text") || name.contains("Paragraph") || name.contains("Label")) return PartKind.TEXT
+    return PartKind.NONE
+  }
+
+  private fun isSecret(t: TextView): Boolean {
+    if (t.transformationMethod is PasswordTransformationMethod) return true
+    val type = t.inputType
+    val variation = type and InputType.TYPE_MASK_VARIATION
+    val cls = type and InputType.TYPE_MASK_CLASS
+    return (cls == InputType.TYPE_CLASS_TEXT && (variation == InputType.TYPE_TEXT_VARIATION_PASSWORD ||
+      variation == InputType.TYPE_TEXT_VARIATION_WEB_PASSWORD || variation == InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD)) ||
+      (cls == InputType.TYPE_CLASS_NUMBER && variation == InputType.TYPE_NUMBER_VARIATION_PASSWORD)
+  }
+
+  private fun clips(v: View): Boolean = v !is ViewGroup || v.childCount == 0 || v.clipChildren
+
+  private fun hasContent(v: View): Boolean = v !is ViewGroup || v.childCount == 0 || v.background != null
+
+  private val corners = FloatArray(8)
+
+  /**
+   * Where the view is in the frame, in points: all four corners mapped through
+   * every parent's scale, turn and scroll, then the box around them, grown (H10)
+   * and clipped to the frame (H9). null when none of it shows.
+   */
+  fun rect(v: View, root: WalkRoot, frameW: Float, frameH: Float, density: Float): RectF? {
+    val r = RectF(0f, 0f, v.width.toFloat(), v.height.toFloat())
+    var cur: View = v
+    while (cur !== root.view) {
+      val m: Matrix = cur.matrix
+      if (!m.isIdentity) {
+        corners[0] = r.left; corners[1] = r.top; corners[2] = r.right; corners[3] = r.top
+        corners[4] = r.right; corners[5] = r.bottom; corners[6] = r.left; corners[7] = r.bottom
+        m.mapPoints(corners)
+        r.set(
+          minOf(corners[0], corners[2], corners[4], corners[6]), minOf(corners[1], corners[3], corners[5], corners[7]),
+          maxOf(corners[0], corners[2], corners[4], corners[6]), maxOf(corners[1], corners[3], corners[5], corners[7]),
+        )
+      }
+      r.offset(cur.left.toFloat(), cur.top.toFloat())
+      val p = cur.parent as? View ?: return null // not attached under this root
+      r.offset(-p.scrollX.toFloat(), -p.scrollY.toFloat())
+      cur = p
+    }
+    r.offset(root.dx, root.dy)
+    val out = RectF(r.left / density - GROW, r.top / density - GROW, r.right / density + GROW, r.bottom / density + GROW)
+    if (!out.intersect(0f, 0f, frameW, frameH)) return null
+    if (out.width() <= 0f || out.height() <= 0f) return null
+    out.set(kotlin.math.floor(out.left), kotlin.math.floor(out.top), kotlin.math.ceil(out.right), kotlin.math.ceil(out.bottom))
+    return out
+  }
+}

package/ios/BuoyFrames.m

@@ -0,0 +1,17 @@
+// Bridge for the Swift module in BuoyFrames.swift. A plain RN module, so it
+// works on the old architecture and, through the interop layer, the new one.
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(BuoyFrames, NSObject)
+RCT_EXTERN_METHOD(configure:(NSDictionary *)options)
+RCT_EXTERN_METHOD(status:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(takeMedia:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(captureLast:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(probe:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(resume)
+RCT_EXTERN_METHOD(startVideo:(BOOL)always)
+RCT_EXTERN_METHOD(stopVideo)
+RCT_EXTERN_METHOD(mark)
+RCT_EXTERN_METHOD(clear)
+RCT_EXTERN_METHOD(invalidate)
+@end