react-native-tvos 0.83.4-1 → 0.83.6-0

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.mm

@@ -9,6 +9,28 @@
 #import <React/RCTUtils.h>
 #import <react/utils/FloatComparison.h>
 
+#if TARGET_OS_TV
+// Layer subclass that can block all animations when scrollAnimationEnabled is NO.
+// This intercepts animations at the point they're added to the layer, which catches
+// all animation sources: UIView animations, focus coordinator animations, and
+// Core Animation implicit/explicit animations.
+@interface RCTScrollViewLayer : CALayer
+@property (nonatomic, assign) BOOL blockAnimations;
+@end
+
+@implementation RCTScrollViewLayer
+
+- (void)addAnimation:(CAAnimation *)anim forKey:(NSString *)key
+{
+  if (_blockAnimations) {
+    return;
+  }
+  [super addAnimation:anim forKey:key];
+}
+
+@end
+#endif
+
 @interface RCTEnhancedScrollView () <UIScrollViewDelegate>
 @end
 
@@ -17,6 +39,13 @@
   BOOL _isSetContentOffsetDisabled;
 }
 
+#if TARGET_OS_TV
++ (Class)layerClass
+{
+  return [RCTScrollViewLayer class];
+}
+#endif
+
 + (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key
 {
   if ([key isEqualToString:@"delegate"]) {
@@ -28,9 +57,18 @@
   return [super automaticallyNotifiesObserversForKey:key];
 }
 
+- (void)setScrollAnimationEnabled:(BOOL)scrollAnimationEnabled
+{
+  _scrollAnimationEnabled = scrollAnimationEnabled;
+#if TARGET_OS_TV
+  ((RCTScrollViewLayer *)self.layer).blockAnimations = !scrollAnimationEnabled;
+#endif
+}
+
 - (instancetype)initWithFrame:(CGRect)frame
 {
   if (self = [super initWithFrame:frame]) {
+    _scrollAnimationEnabled = YES;
     // We set the default behavior to "never" so that iOS
     // doesn't do weird things to UIScrollView insets automatically
     // and keeps it as an opt-in behavior.
@@ -102,6 +140,46 @@
       RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"));
 }
 
+- (void)setContentOffset:(CGPoint)contentOffset animated:(BOOL)animated
+{
+  if (_isSetContentOffsetDisabled) {
+    return;
+  }
+#if TARGET_OS_TV
+  animated = animated && _scrollAnimationEnabled;
+#endif
+  [super setContentOffset:CGPointMake(
+      RCTSanitizeNaNValue(contentOffset.x, @"scrollView.contentOffset.x"),
+      RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"))
+                 animated:animated];
+}
+
+- (void)scrollRectToVisible:(CGRect)rect animated:(BOOL)animated
+{
+#if TARGET_OS_TV
+  animated = animated && _scrollAnimationEnabled;
+#endif
+  [super scrollRectToVisible:rect animated:animated];
+}
+
+#if TARGET_OS_TV
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
+{
+  if (_scrollAnimationEnabled) {
+    [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+    return;
+  }
+
+  // When scrollAnimationEnabled is NO, don't call super and don't scroll here.
+  // RCTScrollViewComponentView.didUpdateFocusInContext handles all scrolling
+  // (both snap and non-snap cases) when animation is disabled. Scrolling here
+  // as well would cause conflicts — e.g. at the end of a snapToInterval list,
+  // this method computes a "just make visible" position while the component view
+  // computes the correct snapped position, causing a bounce effect.
+}
+#endif
+
 - (void)setFrame:(CGRect)frame
 {
   [super setFrame:frame];

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm

@@ -434,6 +434,9 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
 
   scrollView.snapToStart = newScrollViewProps.snapToStart;
   scrollView.snapToEnd = newScrollViewProps.snapToEnd;
+#if TARGET_OS_TV
+  scrollView.scrollAnimationEnabled = newScrollViewProps.scrollAnimationEnabled;
+#endif
 
   if (oldScrollViewProps.snapToOffsets != newScrollViewProps.snapToOffsets) {
     NSMutableArray<NSNumber *> *snapToOffsets = [NSMutableArray array];
@@ -1235,7 +1238,7 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         ? CGPointMake(targetOffset, scrollView.contentOffset.y)
         : CGPointMake(scrollView.contentOffset.x, targetOffset);
     self.preferredContentOffset = targetContentOffset;
-    [_scrollView setContentOffset:targetContentOffset animated:YES];
+    [_scrollView setContentOffset:targetContentOffset animated:scrollProps.scrollAnimationEnabled];
 }
 
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
@@ -1244,7 +1247,18 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     self.preferredContentOffset = NO_PREFERRED_CONTENT_OFFSET;
     const auto &scrollProps = static_cast<const ScrollViewProps &>(*_props);
     BOOL hasItemSnapAlignment = scrollProps.snapToAlignment == ScrollViewSnapToAlignment::Item;
-    if (context.previouslyFocusedView == context.nextFocusedView || (!_props->isTVSelectable && !hasItemSnapAlignment)) {
+    if (context.previouslyFocusedView == context.nextFocusedView) {
+        return;
+    }
+    if (!_props->isTVSelectable && !hasItemSnapAlignment) {
+        if (!scrollProps.scrollAnimationEnabled && [context.nextFocusedView isDescendantOfView:_scrollView]) {
+            // When animations are disabled and there's no snap alignment, manually scroll
+            // the focused view into view instantly. We can't let UIScrollView's default
+            // focus handling do this because it uses deceleration (timer-based) that can't
+            // be blocked by the animation-blocking layer.
+            CGRect targetRect = [context.nextFocusedView convertRect:context.nextFocusedView.bounds toView:_scrollView];
+            [_scrollView scrollRectToVisible:targetRect animated:NO];
+        }
         return;
     }
     if (_props->isTVSelectable && context.nextFocusedView == self) {
@@ -1410,10 +1424,16 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         limitedOffset = MAX(limitedOffset, 0.0);
         limitedOffset = MIN(limitedOffset, maxOffset);
 
-        [UIView animateWithDuration:[self swipeDuration] animations:^{
+        const auto &scrollProps = static_cast<const ScrollViewProps &>(*self->_props);
+        if (scrollProps.scrollAnimationEnabled) {
+            [UIView animateWithDuration:[self swipeDuration] animations:^{
+                self.scrollView.contentOffset =
+                CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
+            }];
+        } else {
             self.scrollView.contentOffset =
             CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
-        }];
+        }
     });
 }
 
@@ -1434,10 +1454,16 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         limitedOffset = MAX(limitedOffset, 0.0);
         limitedOffset = MIN(limitedOffset, maxOffset);
 
-        [UIView animateWithDuration:[self swipeDuration] animations:^{
+        const auto &scrollProps = static_cast<const ScrollViewProps &>(*self->_props);
+        if (scrollProps.scrollAnimationEnabled) {
+            [UIView animateWithDuration:[self swipeDuration] animations:^{
+                self.scrollView.contentOffset =
+                CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
+            }];
+        } else {
             self.scrollView.contentOffset =
             CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
-        }];
+        }
     });
 }
 

package/React/Views/ScrollView/RCTScrollViewManager.m

@@ -106,6 +106,7 @@ RCT_EXPORT_VIEW_PROPERTY(onMomentumScrollEnd, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(inverted, BOOL)
 #if TARGET_OS_TV
 RCT_EXPORT_VIEW_PROPERTY(showsScrollIndex, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(scrollAnimationEnabled, BOOL)
 #endif
 RCT_EXPORT_VIEW_PROPERTY(automaticallyAdjustsScrollIndicatorInsets, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(contentInsetAdjustmentBehavior, UIScrollViewContentInsetAdjustmentBehavior)

package/ReactAndroid/api/ReactAndroid.api

@@ -2257,15 +2257,6 @@ public abstract interface class com/facebook/react/devsupport/interfaces/StackFr
 	public abstract fun toJSON ()Lorg/json/JSONObject;
 }
 
-public final class com/facebook/react/devsupport/interfaces/TracingState : java/lang/Enum {
-	public static final field DISABLED Lcom/facebook/react/devsupport/interfaces/TracingState;
-	public static final field ENABLEDINBACKGROUNDMODE Lcom/facebook/react/devsupport/interfaces/TracingState;
-	public static final field ENABLEDINCDPMODE Lcom/facebook/react/devsupport/interfaces/TracingState;
-	public static fun getEntries ()Lkotlin/enums/EnumEntries;
-	public static fun valueOf (Ljava/lang/String;)Lcom/facebook/react/devsupport/interfaces/TracingState;
-	public static fun values ()[Lcom/facebook/react/devsupport/interfaces/TracingState;
-}
-
 public final class com/facebook/react/fabric/ComponentFactory {
 	public fun <init> ()V
 }

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.83.4-1
+VERSION_NAME=0.83.6-0
 react.internal.publishingGroup=io.github.react-native-tvos
 react.internal.hermesPublishingGroup=com.facebook.hermes
 

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

@@ -10,12 +10,12 @@ package com.facebook.react.devsupport
 import android.content.Context
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.SurfaceDelegateFactory
+import com.facebook.react.devsupport.inspector.TracingState
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener
 import com.facebook.react.devsupport.interfaces.DevLoadingViewManager
 import com.facebook.react.devsupport.interfaces.DevSupportManager
 import com.facebook.react.devsupport.interfaces.PausedInDebuggerOverlayManager
 import com.facebook.react.devsupport.interfaces.RedBoxHandler
-import com.facebook.react.devsupport.interfaces.TracingState
 import com.facebook.react.packagerconnection.RequestHandler
 
 /**
@@ -83,6 +83,6 @@ internal class BridgelessDevSupportManager(
   }
 
   fun tracingState(): TracingState {
-    return TracingState.ENABLEDINCDPMODE
+    return TracingState.ENABLED_IN_CDP_MODE
   }
 }

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/InspectorFlags.kt

@@ -17,7 +17,11 @@ internal object InspectorFlags {
     SoLoader.loadLibrary("react_devsupportjni")
   }
 
+  @DoNotStrip @JvmStatic external fun getScreenshotCaptureEnabled(): Boolean
+
   @DoNotStrip @JvmStatic external fun getFuseboxEnabled(): Boolean
 
   @DoNotStrip @JvmStatic external fun getIsProfilingBuild(): Boolean
+
+  @DoNotStrip @JvmStatic external fun getFrameRecordingEnabled(): Boolean
 }

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

@@ -0,0 +1,16 @@
+/*
+ * 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 beginTimestamp: Long,
+    val endTimestamp: Long,
+    val screenshot: ByteArray? = null,
+)

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

@@ -0,0 +1,275 @@
+/*
+ * 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.view.FrameMetrics
+import android.view.PixelCopy
+import android.view.Window
+import com.facebook.proguard.annotations.DoNotStripAny
+import java.io.ByteArrayOutputStream
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.launch
+
+@DoNotStripAny
+internal class FrameTimingsObserver(
+    private val screenshotsEnabled: Boolean,
+    private val onFrameTimingSequence: (sequence: FrameTimingSequence) -> Unit,
+) {
+  private val isSupported = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  // Serial dispatcher for encoding work (single background thread). We limit to 1 thread to
+  // minimize the performance impact of screenshot recording.
+  private val encodingDispatcher: CoroutineDispatcher =
+      Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+
+  // Stores the most recently captured frame to opportunistically encode after the current frame.
+  // Replaced frames are emitted as timings without screenshots.
+  private val lastFrameBuffer = AtomicReference<FrameData?>(null)
+
+  private var frameCounter: Int = 0
+  private val encodingInProgress = AtomicBoolean(false)
+  @Volatile private var isTracing: Boolean = false
+  @Volatile private var currentWindow: Window? = null
+
+  private data class FrameData(
+      val bitmap: Bitmap,
+      val frameId: Int,
+      val threadId: Int,
+      val beginTimestamp: Long,
+      val endTimestamp: Long,
+  )
+
+  fun start() {
+    if (!isSupported) {
+      return
+    }
+
+    frameCounter = 0
+    encodingInProgress.set(false)
+    lastFrameBuffer.set(null)
+    isTracing = true
+
+    // Emit initial frame event
+    val timestamp = System.nanoTime()
+    emitFrameTiming(timestamp, timestamp)
+
+    currentWindow?.addOnFrameMetricsAvailableListener(frameMetricsListener, mainHandler)
+  }
+
+  fun stop() {
+    if (!isSupported) {
+      return
+    }
+
+    isTracing = false
+
+    currentWindow?.removeOnFrameMetricsAvailableListener(frameMetricsListener)
+    mainHandler.removeCallbacksAndMessages(null)
+    lastFrameBuffer.getAndSet(null)?.bitmap?.recycle()
+  }
+
+  fun setCurrentWindow(window: Window?) {
+    if (!isSupported || currentWindow === window) {
+      return
+    }
+
+    currentWindow?.removeOnFrameMetricsAvailableListener(frameMetricsListener)
+    currentWindow = window
+    if (isTracing) {
+      currentWindow?.addOnFrameMetricsAvailableListener(frameMetricsListener, mainHandler)
+    }
+  }
+
+  private val frameMetricsListener =
+      Window.OnFrameMetricsAvailableListener { _, frameMetrics, _ ->
+        // Guard against calls after stop()
+        if (!isTracing) {
+          return@OnFrameMetricsAvailableListener
+        }
+        val beginTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
+        val endTimestamp = beginTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
+        emitFrameTiming(beginTimestamp, endTimestamp)
+      }
+
+  private fun emitFrameTiming(beginTimestamp: Long, endTimestamp: Long) {
+    val frameId = frameCounter++
+    val threadId = Process.myTid()
+
+    if (!screenshotsEnabled) {
+      // Screenshots disabled - emit without screenshot
+      emitFrameEvent(frameId, threadId, beginTimestamp, endTimestamp, null)
+      return
+    }
+
+    captureScreenshot(frameId, threadId, beginTimestamp, endTimestamp) { frameData ->
+      if (frameData != null) {
+        if (encodingInProgress.compareAndSet(false, true)) {
+          // Not encoding - encode this frame immediately
+          encodeFrame(frameData)
+        } else {
+          // Encoding thread busy - store current screenshot in buffer for tail-capture
+          val oldFrameData = lastFrameBuffer.getAndSet(frameData)
+          if (oldFrameData != null) {
+            // Skipped frame - emit event without screenshot
+            emitFrameEvent(
+                oldFrameData.frameId,
+                oldFrameData.threadId,
+                oldFrameData.beginTimestamp,
+                oldFrameData.endTimestamp,
+                null,
+            )
+            oldFrameData.bitmap.recycle()
+          }
+        }
+      } else {
+        // Failed to capture (e.g. timeout) - emit without screenshot
+        emitFrameEvent(frameId, threadId, beginTimestamp, endTimestamp, null)
+      }
+    }
+  }
+
+  private fun emitFrameEvent(
+      frameId: Int,
+      threadId: Int,
+      beginTimestamp: Long,
+      endTimestamp: Long,
+      screenshot: ByteArray?,
+  ) {
+    CoroutineScope(Dispatchers.Default).launch {
+      onFrameTimingSequence(
+          FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, screenshot)
+      )
+    }
+  }
+
+  private fun encodeFrame(frameData: FrameData) {
+    CoroutineScope(encodingDispatcher).launch {
+      try {
+        val screenshot = encodeScreenshot(frameData.bitmap)
+        emitFrameEvent(
+            frameData.frameId,
+            frameData.threadId,
+            frameData.beginTimestamp,
+            frameData.endTimestamp,
+            screenshot,
+        )
+      } finally {
+        frameData.bitmap.recycle()
+      }
+
+      // Clear encoding flag early, allowing new frames to start fresh encoding sessions
+      encodingInProgress.set(false)
+
+      // Opportunistically encode tail frame (if present) without blocking new frames
+      val tailFrame = lastFrameBuffer.getAndSet(null)
+      if (tailFrame != null) {
+        try {
+          val screenshot = encodeScreenshot(tailFrame.bitmap)
+          emitFrameEvent(
+              tailFrame.frameId,
+              tailFrame.threadId,
+              tailFrame.beginTimestamp,
+              tailFrame.endTimestamp,
+              screenshot,
+          )
+        } finally {
+          tailFrame.bitmap.recycle()
+        }
+      }
+    }
+  }
+
+  // Must be called from the main thread so that PixelCopy captures the current frame.
+  private fun captureScreenshot(
+      frameId: Int,
+      threadId: Int,
+      beginTimestamp: Long,
+      endTimestamp: Long,
+      callback: (FrameData?) -> Unit,
+  ) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      // PixelCopy not available
+      callback(null)
+      return
+    }
+
+    val window = currentWindow
+    if (window == null) {
+      // No window
+      callback(null)
+      return
+    }
+
+    val decorView = window.decorView
+    val width = decorView.width
+    val height = decorView.height
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+
+    PixelCopy.request(
+        window,
+        bitmap,
+        { copyResult ->
+          if (copyResult == PixelCopy.SUCCESS) {
+            callback(FrameData(bitmap, frameId, threadId, beginTimestamp, endTimestamp))
+          } else {
+            bitmap.recycle()
+            callback(null)
+          }
+        },
+        mainHandler,
+    )
+  }
+
+  private fun encodeScreenshot(bitmap: Bitmap): ByteArray? {
+    var scaledBitmap: Bitmap? = null
+    return try {
+      val window = currentWindow ?: return null
+      val width = bitmap.width
+      val height = bitmap.height
+      val density = window.context.resources.displayMetrics.density
+      val scaledWidth = (width / density * SCREENSHOT_SCALE_FACTOR).toInt()
+      val scaledHeight = (height / density * SCREENSHOT_SCALE_FACTOR).toInt()
+      scaledBitmap = Bitmap.createScaledBitmap(bitmap, scaledWidth, scaledHeight, true)
+
+      val compressFormat =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) Bitmap.CompressFormat.WEBP_LOSSY
+          else Bitmap.CompressFormat.JPEG
+
+      ByteArrayOutputStream(SCREENSHOT_OUTPUT_SIZE_HINT).use { outputStream ->
+        scaledBitmap.compress(compressFormat, SCREENSHOT_QUALITY, outputStream)
+        outputStream.toByteArray()
+      }
+    } catch (e: Exception) {
+      null
+    } finally {
+      scaledBitmap?.recycle()
+    }
+  }
+
+  companion object {
+    private const val SCREENSHOT_SCALE_FACTOR = 1.0f
+    private const val SCREENSHOT_QUALITY = 80
+
+    // Capacity hint for the ByteArrayOutputStream used during bitmap
+    // compression. Sized slightly above typical compressed output to minimise
+    // internal buffer resizing.
+    private const val SCREENSHOT_OUTPUT_SIZE_HINT = 65536 // 64 KB
+  }
+}

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

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

@@ -7,7 +7,7 @@
 
 package com.facebook.react.devsupport.perfmonitor
 
-import com.facebook.react.devsupport.interfaces.TracingState
+import com.facebook.react.devsupport.inspector.TracingState
 
 /**
  * [Experimental] Interface implemented by [com.facebook.react.runtime.ReactHostInspectorTarget]