react-native-tvos 0.83.2-0 → 0.84.0-0

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/ChangeBundleLocationDialog.kt

@@ -33,9 +33,6 @@ internal object ChangeBundleLocationDialog {
   ) {
     val settings = devSettings.packagerConnectionSettings
     val currentHost = settings.debugServerHost
-    settings.debugServerHost = ""
-    val defaultHost = settings.debugServerHost
-    settings.debugServerHost = currentHost
 
     val layout = LinearLayout(context)
     layout.orientation = LinearLayout.VERTICAL
@@ -60,11 +57,11 @@ internal object ChangeBundleLocationDialog {
     input.setTextColor(-0x1000000)
     input.setText(currentHost)
 
-    val defaultHostSuggestion = Button(context)
-    defaultHostSuggestion.text = defaultHost
-    defaultHostSuggestion.textSize = 12f
-    defaultHostSuggestion.isAllCaps = false
-    defaultHostSuggestion.setOnClickListener { input.setText(defaultHost) }
+    val currentHostSuggestion = Button(context)
+    currentHostSuggestion.text = currentHost
+    currentHostSuggestion.textSize = 12f
+    currentHostSuggestion.isAllCaps = false
+    currentHostSuggestion.setOnClickListener { input.setText(currentHost) }
 
     val networkHost = getDevServerNetworkIpAndPort(context)
     val networkHostSuggestion = Button(context)
@@ -80,8 +77,12 @@ internal object ChangeBundleLocationDialog {
             LinearLayout.LayoutParams.MATCH_PARENT,
             LinearLayout.LayoutParams.WRAP_CONTENT,
         )
-    suggestionRow.addView(defaultHostSuggestion)
-    suggestionRow.addView(networkHostSuggestion)
+    suggestionRow.addView(currentHostSuggestion)
+
+    if (currentHost != networkHost) {
+      // We don't want to display two buttons with the same host suggestion.
+      suggestionRow.addView(networkHostSuggestion)
+    }
 
     val instructions = TextView(context)
     instructions.text =

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/CxxInspectorPackagerConnection.kt

@@ -9,11 +9,17 @@ package com.facebook.react.devsupport
 
 import android.os.Handler
 import android.os.Looper
+import com.facebook.common.logging.FLog
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.common.annotations.VisibleForTesting
 import com.facebook.soloader.SoLoader
 import java.io.Closeable
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+import java.util.ArrayDeque
+import java.util.Queue
 import java.util.concurrent.TimeUnit
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -67,7 +73,7 @@ internal class CxxInspectorPackagerConnection(
    */
   @DoNotStripAny
   private interface IWebSocket : Closeable {
-    fun send(message: String)
+    fun send(chunk: ByteBuffer)
 
     /**
      * Close the WebSocket connection. NOTE: There is no close() method in the C++ interface.
@@ -76,6 +82,95 @@ internal class CxxInspectorPackagerConnection(
     override fun close()
   }
 
+  /**
+   * A simple WebSocket wrapper that prevents having more than 16MiB of messages queued
+   * simultaneously. This is done to stop OkHttp from closing the WebSocket connection.
+   *
+   * https://github.com/facebook/react-native/issues/39651.
+   * https://github.com/square/okhttp/blob/4e7dbec1ea6c9cf8d80422ac9d44b9b185c749a3/okhttp/src/commonJvmAndroid/kotlin/okhttp3/internal/ws/RealWebSocket.kt#L684.
+   */
+  private class InspectorPackagerWebSocketImpl(
+      private val nativeWebSocket: WebSocket,
+      private val handler: Handler,
+  ) : IWebSocket {
+    private val messageQueue: Queue<Pair<String, Int>> = ArrayDeque()
+    private val queueLock = Any()
+    private val drainRunnable =
+        object : Runnable {
+          override fun run() {
+            FLog.d(TAG, "Attempting to drain the message queue after ${drainDelayMs}ms")
+            tryDrainQueue()
+          }
+        }
+
+    /**
+     * We are providing a String to OkHttp's WebSocket, because there is no guarantee that all CDP
+     * clients will support binary data format.
+     */
+    override fun send(chunk: ByteBuffer) {
+      synchronized(queueLock) {
+        val messageSize = chunk.capacity()
+        val message = StandardCharsets.UTF_8.decode(chunk).toString()
+        val currentQueueSize = nativeWebSocket.queueSize()
+
+        if (currentQueueSize + messageSize > MAX_QUEUE_SIZE) {
+          FLog.d(TAG, "Reached queue size limit. Queueing the message.")
+          messageQueue.offer(Pair(message, messageSize))
+          scheduleDrain()
+        } else {
+          if (messageQueue.isEmpty()) {
+            nativeWebSocket.send(message)
+          } else {
+            messageQueue.offer(Pair(message, messageSize))
+            tryDrainQueue()
+          }
+        }
+      }
+    }
+
+    override fun close() {
+      synchronized(queueLock) {
+        handler.removeCallbacks(drainRunnable)
+        messageQueue.clear()
+        nativeWebSocket.close(1000, "End of session")
+      }
+    }
+
+    private fun tryDrainQueue() {
+      synchronized(queueLock) {
+        while (messageQueue.isNotEmpty()) {
+          val (nextMessage, nextMessageSize) = messageQueue.peek() ?: break
+          val currentQueueSize = nativeWebSocket.queueSize()
+
+          if (currentQueueSize + nextMessageSize <= MAX_QUEUE_SIZE) {
+            messageQueue.poll()
+            if (!nativeWebSocket.send(nextMessage)) {
+              // The WebSocket is closing, closed, or cancelled.
+              handler.removeCallbacks(drainRunnable)
+              messageQueue.clear()
+
+              break
+            }
+          } else {
+            scheduleDrain()
+            break
+          }
+        }
+      }
+    }
+
+    private fun scheduleDrain() {
+      FLog.d(TAG, "Scheduled a task to drain messages queue.")
+      handler.removeCallbacks(drainRunnable)
+      handler.postDelayed(drainRunnable, drainDelayMs)
+    }
+
+    companion object {
+      private val TAG: String = InspectorPackagerWebSocketImpl::class.java.simpleName
+      private const val drainDelayMs: Long = 100
+    }
+  }
+
   /** Java implementation of the C++ InspectorPackagerConnectionDelegate interface. */
   private class DelegateImpl {
     private val httpClient =
@@ -130,15 +225,8 @@ internal class CxxInspectorPackagerConnection(
                 }
               },
           )
-      return object : IWebSocket {
-        override fun send(message: String) {
-          webSocket.send(message)
-        }
 
-        override fun close() {
-          webSocket.close(1000, "End of session")
-        }
-      }
+      return InspectorPackagerWebSocketImpl(webSocket, handler)
     }
 
     @DoNotStrip
@@ -152,6 +240,8 @@ internal class CxxInspectorPackagerConnection(
       SoLoader.loadLibrary("react_devsupportjni")
     }
 
+    @VisibleForTesting internal const val MAX_QUEUE_SIZE = 16L * 1024 * 1024 // 16MiB
+
     @JvmStatic
     private external fun initHybrid(
         url: String,

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DefaultDevLoadingViewImplementation.kt

@@ -8,6 +8,7 @@
 package com.facebook.react.devsupport
 
 import android.content.Context
+import android.graphics.Color
 import android.graphics.Rect
 import android.view.Gravity
 import android.view.LayoutInflater
@@ -33,14 +34,21 @@ public class DefaultDevLoadingViewImplementation(
   private var devLoadingPopup: PopupWindow? = null
 
   override fun showMessage(message: String) {
-    showMessage(message, color = null, backgroundColor = null)
+    showMessage(message, color = null, backgroundColor = null, dismissButton = false)
   }
 
-  override fun showMessage(message: String, color: Double?, backgroundColor: Double?) {
+  override fun showMessage(
+      message: String,
+      color: Double?,
+      backgroundColor: Double?,
+      dismissButton: Boolean?,
+  ) {
     if (!isEnabled) {
       return
     }
-    UiThreadUtil.runOnUiThread { showInternal(message, color, backgroundColor) }
+    UiThreadUtil.runOnUiThread {
+      showInternal(message, color, backgroundColor, dismissButton ?: false)
+    }
   }
 
   override fun updateProgress(status: String?, done: Int?, total: Int?) {
@@ -63,7 +71,12 @@ public class DefaultDevLoadingViewImplementation(
     }
   }
 
-  private fun showInternal(message: String, color: Double?, backgroundColor: Double?) {
+  private fun showInternal(
+      message: String,
+      color: Double?,
+      backgroundColor: Double?,
+      dismissButton: Boolean,
+  ) {
     if (devLoadingPopup?.isShowing == true) {
       // already showing
       return
@@ -86,24 +99,56 @@ public class DefaultDevLoadingViewImplementation(
       val topOffset = rectangle.top
       val inflater =
           currentActivity.getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
-      val view = inflater.inflate(R.layout.dev_loading_view, null) as TextView
-      view.text = message
-      if (color != null) {
-        view.setTextColor(color.toInt())
+      val rootView = inflater.inflate(R.layout.dev_loading_view, null) as ViewGroup
+      val textView = rootView.findViewById<TextView>(R.id.loading_text)
+      textView.text = message
+
+      val dismissButtonView = rootView.findViewById<android.widget.Button>(R.id.dismiss_button)
+
+      if (dismissButton) {
+        dismissButtonView.visibility = android.view.View.VISIBLE
+      } else {
+        dismissButtonView.visibility = android.view.View.GONE
       }
-      if (backgroundColor != null) {
-        view.setBackgroundColor(backgroundColor.toInt())
+
+      // Use provided colors or defaults (matching iOS behavior)
+      val textColor = color?.toInt() ?: Color.WHITE
+      val bgColor = backgroundColor?.toInt() ?: Color.rgb(64, 64, 64) // Default grey
+
+      textView.setTextColor(textColor)
+      rootView.setBackgroundColor(bgColor)
+
+      if (dismissButton) {
+        dismissButtonView.setTextColor(textColor)
+
+        // Darken the background color for the button
+        val red = (Color.red(bgColor) * 0.7).toInt()
+        val green = (Color.green(bgColor) * 0.7).toInt()
+        val blue = (Color.blue(bgColor) * 0.7).toInt()
+        val darkerColor = Color.rgb(red, green, blue)
+
+        // Create rounded drawable for button
+        val drawable = android.graphics.drawable.GradientDrawable()
+        drawable.setColor(darkerColor)
+        drawable.cornerRadius = 15 * rootView.resources.displayMetrics.density
+        dismissButtonView.background = drawable
+
+        dismissButtonView.setOnClickListener { hideInternal() }
       }
-      view.setOnClickListener { hideInternal() }
+
+      // Allow tapping anywhere on the banner to dismiss
+      rootView.setOnClickListener { hideInternal() }
+
       val popup =
           PopupWindow(
-              view,
+              rootView,
               ViewGroup.LayoutParams.MATCH_PARENT,
               ViewGroup.LayoutParams.WRAP_CONTENT,
           )
       popup.showAtLocation(currentActivity.window.decorView, Gravity.NO_GRAVITY, 0, topOffset)
-      devLoadingView = view
+      devLoadingView = textView // Store the TextView for updateProgress()
       devLoadingPopup = popup
+
       // TODO T164786028: Find out the root cause of the BadTokenException exception here
     } catch (e: WindowManager.BadTokenException) {
       FLog.e(

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DefaultDevSupportManagerFactory.kt

@@ -18,10 +18,10 @@ import com.facebook.react.devsupport.interfaces.RedBoxHandler
 import com.facebook.react.packagerconnection.RequestHandler
 
 /**
- * A simple factory that creates instances of [DevSupportManager] implementations. Uses reflection
- * to create BridgeDevSupportManager if it exists. This allows ProGuard to strip that class and its
- * dependencies in release builds. If the class isn't found, [PerftestDevSupportManager] is returned
- * instead.
+ * A simple factory that creates instances of [DevSupportManager] implementations.
+ *
+ * The first create() method is for the Old Architecture flow and is deprecated and should not be
+ * used anymore. The second create() method is for the New Architecture/Bridgeless flow.
  */
 internal class DefaultDevSupportManagerFactory : DevSupportManagerFactory {
 
@@ -44,57 +44,12 @@ internal class DefaultDevSupportManagerFactory : DevSupportManagerFactory {
       surfaceDelegateFactory: SurfaceDelegateFactory?,
       devLoadingViewManager: DevLoadingViewManager?,
       pausedInDebuggerOverlayManager: PausedInDebuggerOverlayManager?,
-  ): DevSupportManager {
-    return if (!enableOnCreate) {
-      ReleaseDevSupportManager()
-    } else
-        try {
-          // Developer support is enabled, we now must choose whether to return a DevSupportManager,
-          // or a more lean profiling-only PerftestDevSupportManager. We make the choice by first
-          // trying to return the full support DevSupportManager and if it fails, then just
-          // return PerftestDevSupportManager.
-
-          // ProGuard is surprisingly smart in this case and will keep a class if it detects a call
-          // to
-          // Class.forName() with a static string. So instead we generate a quasi-dynamic string to
-          // confuse it.
-          val className =
-              StringBuilder(DEVSUPPORT_IMPL_PACKAGE)
-                  .append(".")
-                  .append(DEVSUPPORT_IMPL_CLASS)
-                  .toString()
-          val devSupportManagerClass = Class.forName(className)
-          val constructor =
-              devSupportManagerClass.getConstructor(
-                  Context::class.java,
-                  ReactInstanceDevHelper::class.java,
-                  String::class.java,
-                  Boolean::class.javaPrimitiveType,
-                  RedBoxHandler::class.java,
-                  DevBundleDownloadListener::class.java,
-                  Int::class.javaPrimitiveType,
-                  MutableMap::class.java,
-                  SurfaceDelegateFactory::class.java,
-                  DevLoadingViewManager::class.java,
-                  PausedInDebuggerOverlayManager::class.java,
-              )
-          constructor.newInstance(
-              applicationContext,
-              reactInstanceManagerHelper,
-              packagerPathForJSBundleName,
-              true,
-              redBoxHandler,
-              devBundleDownloadListener,
-              minNumShakes,
-              customPackagerCommandHandlers,
-              surfaceDelegateFactory,
-              devLoadingViewManager,
-              pausedInDebuggerOverlayManager,
-          ) as DevSupportManager
-        } catch (e: Exception) {
-          PerftestDevSupportManager(applicationContext)
-        }
-  }
+  ): DevSupportManager =
+      if (!enableOnCreate) {
+        ReleaseDevSupportManager()
+      } else {
+        PerftestDevSupportManager(applicationContext)
+      }
 
   override fun create(
       applicationContext: Context,
@@ -129,9 +84,4 @@ internal class DefaultDevSupportManagerFactory : DevSupportManagerFactory {
       } else {
         ReleaseDevSupportManager()
       }
-
-  private companion object {
-    private const val DEVSUPPORT_IMPL_PACKAGE = "com.facebook.react.devsupport"
-    private const val DEVSUPPORT_IMPL_CLASS = "BridgeDevSupportManager"
-  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManagerBase.kt

@@ -52,6 +52,8 @@ import com.facebook.react.devsupport.DevServerHelper.PackagerCommandListener
 import com.facebook.react.devsupport.InspectorFlags.getFuseboxEnabled
 import com.facebook.react.devsupport.StackTraceHelper.convertJavaStackTrace
 import com.facebook.react.devsupport.StackTraceHelper.convertJsStackTrace
+import com.facebook.react.devsupport.inspector.TracingState
+import com.facebook.react.devsupport.inspector.TracingStateProvider
 import com.facebook.react.devsupport.interfaces.BundleLoadCallback
 import com.facebook.react.devsupport.interfaces.DebuggerFrontendPanelName
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener
@@ -66,8 +68,6 @@ import com.facebook.react.devsupport.interfaces.PackagerStatusCallback
 import com.facebook.react.devsupport.interfaces.PausedInDebuggerOverlayManager
 import com.facebook.react.devsupport.interfaces.RedBoxHandler
 import com.facebook.react.devsupport.interfaces.StackFrame
-import com.facebook.react.devsupport.interfaces.TracingState
-import com.facebook.react.devsupport.interfaces.TracingStateProvider
 import com.facebook.react.devsupport.perfmonitor.PerfMonitorDevHelper
 import com.facebook.react.devsupport.perfmonitor.PerfMonitorOverlayManager
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
@@ -396,21 +396,21 @@ public abstract class DevSupportManagerBase(
 
       val analyzePerformanceItemString =
           when (tracingState) {
-            TracingState.ENABLEDINBACKGROUNDMODE ->
+            TracingState.ENABLED_IN_BACKGROUND_MODE ->
                 applicationContext.getString(R.string.catalyst_performance_background)
-            TracingState.ENABLEDINCDPMODE ->
+            TracingState.ENABLED_IN_CDP_MODE ->
                 applicationContext.getString(R.string.catalyst_performance_cdp)
             TracingState.DISABLED ->
                 applicationContext.getString(R.string.catalyst_performance_disabled)
           }
 
-      if (!isConnected || tracingState == TracingState.ENABLEDINCDPMODE) {
+      if (!isConnected || tracingState == TracingState.ENABLED_IN_CDP_MODE) {
         disabledItemKeys.add(analyzePerformanceItemString)
       }
 
       options[analyzePerformanceItemString] =
           when (tracingState) {
-            TracingState.ENABLEDINBACKGROUNDMODE ->
+            TracingState.ENABLED_IN_BACKGROUND_MODE ->
                 DevOptionHandler {
                   UiThreadUtil.runOnUiThread {
                     if (reactInstanceDevHelper is PerfMonitorDevHelper) {
@@ -427,7 +427,7 @@ public abstract class DevSupportManagerBase(
                   if (reactInstanceDevHelper is PerfMonitorDevHelper)
                       reactInstanceDevHelper.inspectorTarget?.resumeBackgroundTrace()
                 }
-            TracingState.ENABLEDINCDPMODE -> DevOptionHandler {}
+            TracingState.ENABLED_IN_CDP_MODE -> DevOptionHandler {}
           }
     }
 

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManagerFactory.kt

@@ -18,10 +18,7 @@ import com.facebook.react.packagerconnection.RequestHandler
 
 public interface DevSupportManagerFactory {
 
-  /**
-   * Factory used by the Old Architecture flow to create a [DevSupportManager] and a
-   * [BridgeDevSupportManager]
-   */
+  /** Factory used by the Old Architecture flow to create a [DevSupportManager]. */
   @Deprecated(
       message =
           "Use the other create() method with useDevSupport parameter for New Architecture. This method will be removed in a future release.",

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/FrameTimingSequence.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.devsupport.inspector
+
+internal data class FrameTimingSequence(
+    val id: Int,
+    val threadId: Int,
+    val beginDrawingTimestamp: Long,
+    val commitTimestamp: Long,
+    val endDrawingTimestamp: Long,
+    val screenshot: String? = null,
+)

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/FrameTimingsObserver.kt

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.devsupport.inspector
+
+import android.graphics.Bitmap
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.Process
+import android.util.Base64
+import android.view.FrameMetrics
+import android.view.PixelCopy
+import android.view.Window
+import com.facebook.proguard.annotations.DoNotStripAny
+import java.io.ByteArrayOutputStream
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@DoNotStripAny
+internal class FrameTimingsObserver(
+    private val window: Window,
+    private val screenshotsEnabled: Boolean,
+    private val onFrameTimingSequence: (sequence: FrameTimingSequence) -> Unit,
+) {
+  private val handler = Handler(Looper.getMainLooper())
+  private var frameCounter: Int = 0
+  private var bitmapBuffer: Bitmap? = null
+
+  private val frameMetricsListener =
+      Window.OnFrameMetricsAvailableListener { _, frameMetrics, _dropCount ->
+        val beginDrawingTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
+        val commitTimestamp =
+            beginDrawingTimestamp + frameMetrics.getMetric(FrameMetrics.INPUT_HANDLING_DURATION)
+        +frameMetrics.getMetric(FrameMetrics.ANIMATION_DURATION)
+        +frameMetrics.getMetric(FrameMetrics.LAYOUT_MEASURE_DURATION)
+        +frameMetrics.getMetric(FrameMetrics.DRAW_DURATION)
+        +frameMetrics.getMetric(FrameMetrics.SYNC_DURATION)
+        val endDrawingTimestamp =
+            beginDrawingTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
+
+        val frameId = frameCounter++
+        val threadId = Process.myTid()
+
+        CoroutineScope(Dispatchers.Default).launch {
+          val screenshot = if (screenshotsEnabled) captureScreenshot() else null
+
+          onFrameTimingSequence(
+              FrameTimingSequence(
+                  frameId,
+                  threadId,
+                  beginDrawingTimestamp,
+                  commitTimestamp,
+                  endDrawingTimestamp,
+                  screenshot,
+              )
+          )
+        }
+      }
+
+  private suspend fun captureScreenshot(): String? = suspendCoroutine { continuation ->
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      continuation.resume(null)
+      return@suspendCoroutine
+    }
+
+    val decorView = window.decorView
+    val width = decorView.width
+    val height = decorView.height
+
+    // Reuse bitmap if dimensions haven't changed
+    val bitmap =
+        bitmapBuffer?.let {
+          if (it.width == width && it.height == height) {
+            it
+          } else {
+            null
+          }
+        } ?: Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).also { bitmapBuffer = it }
+
+    PixelCopy.request(
+        window,
+        bitmap,
+        { copyResult ->
+          if (copyResult == PixelCopy.SUCCESS) {
+            CoroutineScope(Dispatchers.Default).launch {
+              try {
+                val scaleFactor = 0.25f
+                val scaledWidth = (width * scaleFactor).toInt()
+                val scaledHeight = (height * scaleFactor).toInt()
+                val scaledBitmap =
+                    Bitmap.createScaledBitmap(bitmap, scaledWidth, scaledHeight, true)
+
+                val outputStream = ByteArrayOutputStream()
+                val compressFormat =
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
+                        Bitmap.CompressFormat.WEBP_LOSSY
+                    else Bitmap.CompressFormat.WEBP
+                scaledBitmap.compress(compressFormat, 0, outputStream)
+                val bytes = outputStream.toByteArray()
+                val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP)
+                continuation.resume(base64)
+
+                scaledBitmap.recycle()
+              } catch (e: Exception) {
+                continuation.resume(null)
+              }
+            }
+          } else {
+            continuation.resume(null)
+          }
+        },
+        handler,
+    )
+  }
+
+  fun start() {
+    frameCounter = 0
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      return
+    }
+
+    window.addOnFrameMetricsAvailableListener(frameMetricsListener, handler)
+  }
+
+  fun stop() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+      return
+    }
+
+    window.removeOnFrameMetricsAvailableListener(frameMetricsListener)
+    handler.removeCallbacksAndMessages(null)
+
+    bitmapBuffer?.recycle()
+    bitmapBuffer = null
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/InspectorNetworkHelper.kt

@@ -66,7 +66,7 @@ internal object InspectorNetworkHelper {
               response.body().use { responseBody ->
                 if (responseBody != null) {
                   val inputStream = responseBody.byteStream()
-                  val chunkSize = 1024
+                  val chunkSize = 8 * 1024 // 8Kb
                   val buffer = ByteArray(chunkSize)
                   var bytesRead: Int
 

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/TracingState.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.devsupport.inspector
+
+import com.facebook.proguard.annotations.DoNotStripAny
+
+@DoNotStripAny
+internal enum class TracingState {
+  DISABLED, // There is no active trace
+  ENABLED_IN_BACKGROUND_MODE, // Trace is currently running in background mode
+  ENABLED_IN_CDP_MODE, // Trace is currently running in CDP mode
+}

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/inspector/TracingStateListener.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.devsupport.inspector
+
+import com.facebook.proguard.annotations.DoNotStripAny
+
+@DoNotStripAny
+internal fun interface TracingStateListener {
+  public fun onStateChanged(state: TracingState, screenshotsEnabled: Boolean)
+}

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/{interfaces → inspector}/TracingStateProvider.kt

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.devsupport.interfaces
+package com.facebook.react.devsupport.inspector
 
 internal interface TracingStateProvider {
   fun getTracingState(): TracingState