Add dynamic sampling to frame screenshots

Summary:
Update Android frame screenshot processing to skip frames when encoding is backed up, ensuring we capture at most every 5th frame when pending work exists.

**Motivation**: Prevents truncated trace data on slower devices (e.g. missing screenshots for the last 1/3 of the trace), with the tradeoff of some intermediate frame data loss (note: we **do** emit a frame event, just without a visual snapshot).

NOTE: This still does not yet solve crashes (OkHttp network chunk size overflow) for heavy frame data at a high FPS on fast devices (coming next).

**Throttling logic**

- Each frame increments `framesSinceLastEnqueue`.
- If there are pending frames AND we haven't reached the minimum sample rate (5), the frame is skipped.
- When a frame is enqueued, reset the counter and track it as pending.
- When processing completes (in either screenshot or non-screenshot path), decrement the pending count.

**🚧 Still under experimentation**

A `MIN_FRAME_SAMPLE_RATE` of 5 may be too destructive, in which case we will evolve this over time.

NOTE: ⚠️ We do still typically loose a small region of pending frames at the end of a trace, but this is now more reasonable. A further fix (likely unnecessary) is to add the lifecycle methods to await frame processing before responding over CDP.

Changelog: [Internal]

Differential Revision: D95987488

Author: huntie

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/FrameTimingsObserver.kt

@@ -17,6 +17,7 @@ import android.view.PixelCopy
 import android.view.Window
 import com.facebook.proguard.annotations.DoNotStripAny
 import java.io.ByteArrayOutputStream
+import java.util.concurrent.atomic.AtomicInteger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -30,6 +31,8 @@ internal class FrameTimingsObserver(
   private val mainHandler = Handler(Looper.getMainLooper())
 
   private var frameCounter: Int = 0
+  private var framesSinceLastEnqueue: Int = 0
+  private val pendingFrameCount = AtomicInteger(0)
   @Volatile private var isTracing: Boolean = false
   @Volatile private var currentWindow: Window? = null
 
@@ -39,6 +42,8 @@ internal class FrameTimingsObserver(
     }
 
     frameCounter = 0
+    framesSinceLastEnqueue = 0
+    pendingFrameCount.set(0)
     isTracing = true
 
     // Capture initial screenshot to ensure there's always at least one frame
@@ -86,19 +91,34 @@ internal class FrameTimingsObserver(
 
   private fun emitFrameTiming(beginTimestamp: Long, endTimestamp: Long) {
     val frameId = frameCounter++
+    framesSinceLastEnqueue++
+
     val threadId = Process.myTid()
 
-    if (screenshotsEnabled) {
+    // Throttle screenshot capture if we have pending frames and haven't reached minimum sample rate
+    val shouldCaptureScreenshot =
+        screenshotsEnabled &&
+            (pendingFrameCount.get() == 0 || framesSinceLastEnqueue >= MIN_FRAME_SAMPLE_RATE)
+
+    if (shouldCaptureScreenshot) {
+      framesSinceLastEnqueue = 0
+      pendingFrameCount.incrementAndGet()
+
       // Initiate PixelCopy immediately on the main thread, while still in the current frame,
       // then process and emit asynchronously once the copy is complete.
       captureScreenshot { screenshot ->
         CoroutineScope(Dispatchers.Default).launch {
-          onFrameTimingSequence(
-              FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, screenshot)
-          )
+          try {
+            onFrameTimingSequence(
+                FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, screenshot)
+            )
+          } finally {
+            pendingFrameCount.decrementAndGet()
+          }
         }
       }
     } else {
+      // Emit frame timing without screenshot (either screenshots disabled or when throttled)
       CoroutineScope(Dispatchers.Default).launch {
         onFrameTimingSequence(
             FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, null)
@@ -172,6 +192,9 @@ internal class FrameTimingsObserver(
   }
 
   companion object {
+    // Minimum frame sample rate - ensures we enqueue at least every 5 frames
+    private const val MIN_FRAME_SAMPLE_RATE = 5
+
     private const val SCREENSHOT_SCALE_FACTOR = 0.75f
     private const val SCREENSHOT_QUALITY = 80