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

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostInspectorTarget.kt

@@ -12,7 +12,9 @@ import com.facebook.proguard.annotations.DoNotStripAny
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
-import com.facebook.react.devsupport.interfaces.TracingState
+import com.facebook.react.devsupport.inspector.FrameTimingSequence
+import com.facebook.react.devsupport.inspector.TracingState
+import com.facebook.react.devsupport.inspector.TracingStateListener
 import com.facebook.react.devsupport.perfmonitor.PerfMonitorInspectorTarget
 import com.facebook.react.devsupport.perfmonitor.PerfMonitorUpdateListener
 import com.facebook.soloader.SoLoader
@@ -41,11 +43,13 @@ internal class ReactHostInspectorTarget(reactHostImpl: ReactHostImpl) :
 
   external fun stopAndDiscardBackgroundTrace()
 
-  external fun tracingStateAsInt(): Int
+  external override fun getTracingState(): TracingState
 
-  override fun getTracingState(): TracingState {
-    return TracingState.entries[tracingStateAsInt()]
-  }
+  external fun registerTracingStateListener(listener: TracingStateListener): Long
+
+  external fun unregisterTracingStateListener(subscriptionId: Long)
+
+  external fun recordFrameTimings(frameTimingSequence: FrameTimingSequence)
 
   override fun addPerfMonitorListener(listener: PerfMonitorUpdateListener) {
     perfMonitorListeners.add(listener)
@@ -63,7 +67,7 @@ internal class ReactHostInspectorTarget(reactHostImpl: ReactHostImpl) :
   override fun resumeBackgroundTrace() {
     startBackgroundTrace()
     perfMonitorListeners.forEach { listener ->
-      listener.onRecordingStateChanged(TracingState.ENABLEDINBACKGROUNDMODE)
+      listener.onRecordingStateChanged(TracingState.ENABLED_IN_BACKGROUND_MODE)
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/common/UiModeUtils.kt

@@ -7,12 +7,32 @@
 
 package com.facebook.react.views.common
 
+import android.app.UiModeManager
 import android.content.Context
 import android.content.res.Configuration
 
 /** Utility object providing static methods for working with UI mode properties from Context. */
 internal object UiModeUtils {
 
+  private var isTVDeviceCached: Boolean? = null
+
+  /**
+   * Determines whether the device is a TV (Android TV / Fire TV).
+   * The result is cached after the first call.
+   *
+   * @param context The context to check the UI mode from
+   * @return true if the device is running in television mode, false otherwise
+   */
+  @JvmStatic
+  fun isTVDevice(context: Context): Boolean {
+    return isTVDeviceCached ?: run {
+      val uiModeManager = context.getSystemService(Context.UI_MODE_SERVICE) as? UiModeManager
+      val result = uiModeManager?.currentModeType == Configuration.UI_MODE_TYPE_TELEVISION
+      isTVDeviceCached = result
+      result
+    }
+  }
+
   /**
    * Determines whether the current UI mode is dark mode
    *

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollView.java

@@ -29,6 +29,7 @@ import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.ViewParent;
 import android.view.accessibility.AccessibilityNodeInfo;
 import android.widget.HorizontalScrollView;
 import android.widget.OverScroller;
@@ -38,6 +39,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.build.ReactBuildConfig;
@@ -136,6 +138,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private int mFadingEdgeLengthStart = 0;
   private int mFadingEdgeLengthEnd = 0;
   private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactHorizontalScrollView(Context context) {
     this(context, null);
@@ -247,9 +251,23 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return mScrollEnabled && super.canScrollHorizontally(direction);
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      // Jump instantly to the target position instead of animating.
+      scrollTo(mScroller.getFinalX(), mScroller.getFinalY());
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -388,6 +406,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mSnapToItemPadding = snapToItemPadding;
   }
 
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getLeftFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -603,7 +625,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    // Temporarily block HorizontalScrollView's internal scrollToChild from running
+    // during super.requestChildFocus — we've already handled scrolling in requestChildFocus.
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
   }
 
   @Override
@@ -654,6 +680,18 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return scrollDelta != 0 && Math.abs(scrollDelta) < (mTempRect.width() / 2);
   }
 
+  /** Returns whether the given view is a descendant of the given ancestor */
+  private static boolean isDescendantOf(View view, View ancestor) {
+    ViewParent parent = view.getParent();
+    while (parent != null) {
+      if (parent == ancestor) {
+        return true;
+      }
+      parent = parent.getParent();
+    }
+    return false;
+  }
+
   private void scrollToChild(View child) {
     int scrollDelta = getScrollDelta(child);
 
@@ -796,21 +834,41 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   public boolean arrowScroll(int direction) {
     boolean handled = false;
 
-    if (mPagingEnabled) {
+    if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+      // When snapToAlignment is "item", find the next focusable and request focus directly.
+      // This avoids super.arrowScroll() which starts its own scroll animation that conflicts
+      // with tryScrollSnapToChild's snap scrolling.
+      // requestChildFocus → tryScrollSnapToChild handles scrolling.
+      View currentFocused = findFocus();
+      View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+      if (nextFocused != null && nextFocused != currentFocused && nextFocused != this) {
+        nextFocused.requestFocus(direction);
+        handled = true;
+      }
+    } else if (mPagingEnabled) {
       mPagedArrowScrolling = true;
 
       if (getChildCount() > 0) {
         View currentFocused = findFocus();
         View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
         View rootChild = getContentView();
-        if (rootChild != null && nextFocused != null && nextFocused.getParent() == rootChild) {
-          if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
-            smoothScrollToNextPage(direction);
+        if (rootChild != null && nextFocused != null && isDescendantOf(nextFocused, rootChild)) {
+          if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+            // When snapToAlignment is "item", don't use smoothScrollToNextPage (which scrolls
+            // by full page width and ignores snapToItemPadding). Instead just request focus —
+            // requestChildFocus → tryScrollSnapToChild handles scrolling with correct padding.
+            nextFocused.requestFocus();
+          } else {
+            if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
+              smoothScrollToNextPage(direction);
+            }
+            nextFocused.requestFocus();
           }
-          nextFocused.requestFocus();
           handled = true;
         } else {
-          smoothScrollToNextPage(direction);
+          if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+            smoothScrollToNextPage(direction);
+          }
           handled = true;
         }
       }
@@ -1595,7 +1653,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollViewManager.kt

@@ -164,6 +164,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToItemPadding(px)
   }
 
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactHorizontalScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(
       view: ReactHorizontalScrollView,

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollView.java

@@ -24,6 +24,7 @@ import android.graphics.Rect;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
+import android.view.FocusFinder;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
@@ -38,6 +39,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
@@ -134,6 +136,8 @@ public class ReactScrollView extends ScrollView
   private int mFadingEdgeLengthStart;
   private int mFadingEdgeLengthEnd;
   private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactScrollView(Context context) {
     this(context, null);
@@ -358,6 +362,10 @@ public class ReactScrollView extends ScrollView
     mSnapToItemPadding = snapToItemPadding;
   }
 
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getTopFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -539,6 +547,24 @@ public class ReactScrollView extends ScrollView
     return true;
   }
 
+  @Override
+  public boolean arrowScroll(int direction) {
+    if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+      // When snapToAlignment is "item", find the next focusable and request focus directly.
+      // This avoids super.arrowScroll() which starts its own scroll animation that conflicts
+      // with tryScrollSnapToChild's snap scrolling.
+      // requestChildFocus → tryScrollSnapToChild handles scrolling.
+      View currentFocused = findFocus();
+      View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+      if (nextFocused != null && nextFocused != currentFocused && nextFocused != this) {
+        nextFocused.requestFocus(direction);
+        return true;
+      }
+      return false;
+    }
+    return super.arrowScroll(direction);
+  }
+
   /**
    * Since ReactScrollView handles layout changes on JS side, it does not call super.onlayout due to
    * which mIsLayoutDirty flag in ScrollView remains true and prevents scrolling to child when
@@ -562,7 +588,9 @@ public class ReactScrollView extends ScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
   }
 
   private int getScrollDelta(View descendent) {
@@ -606,9 +634,23 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      // Jump instantly to the target position instead of animating.
+      scrollTo(mScroller.getFinalX(), mScroller.getFinalY());
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -1362,7 +1404,11 @@ public class ReactScrollView extends ScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewManager.kt

@@ -148,6 +148,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToItemPadding(px)
   }
 
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(view: ReactScrollView, removeClippedSubviews: Boolean) {
     view.removeClippedSubviews = removeClippedSubviews

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextView.java

@@ -30,6 +30,7 @@ import androidx.appcompat.widget.TintContextWrapper;
 import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.customview.widget.ExploreByTouchHelper;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
@@ -151,14 +152,38 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     //         mViewFlags = SOUND_EFFECTS_ENABLED | HAPTIC_FEEDBACK_ENABLED |
     // LAYOUT_DIRECTION_INHERIT;
     setEnabled(true);
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      setFocusable(View.FOCUSABLE_AUTO);
-    }
+    // Changed from FOCUSABLE_AUTO to NOT_FOCUSABLE to prevent Android TV's
+    // focus engine from landing on text views when no other views are available
+    setFocusable(View.NOT_FOCUSABLE);
 
     setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
     updateView(); // call after changing ellipsizeLocation in particular
   }
 
+  // On Android TV, prevent text views from becoming focusable.
+  // ReactTextAnchorViewManager.setAccessible() ties isFocusable to the
+  // "accessible" prop, which causes Android TV's D-pad focus engine to land
+  // on text views inside recycled list items (FlashList), triggering
+  // requestChildFocus -> scrollToChild scroll jumps.
+  // On non-TV devices, focusability is left unchanged for accessibility.
+  @Override
+  public void setFocusable(boolean focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(false);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
+  @Override
+  public void setFocusable(int focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(View.NOT_FOCUSABLE);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
   private static WritableMap inlineViewJson(
       int visibility, int index, int left, int top, int right, int bottom) {
     WritableMap json = Arguments.createMap();

package/ReactAndroid/src/main/jni/react/devsupport/JInspectorFlags.cpp

@@ -11,6 +11,12 @@
 
 namespace facebook::react::jsinspector_modern {
 
+bool JInspectorFlags::getScreenshotCaptureEnabled(
+    jni::alias_ref<jclass> /*unused*/) {
+  auto& inspectorFlags = InspectorFlags::getInstance();
+  return inspectorFlags.getScreenshotCaptureEnabled();
+}
+
 bool JInspectorFlags::getFuseboxEnabled(jni::alias_ref<jclass> /*unused*/) {
   auto& inspectorFlags = InspectorFlags::getInstance();
   return inspectorFlags.getFuseboxEnabled();
@@ -21,7 +27,18 @@ bool JInspectorFlags::getIsProfilingBuild(jni::alias_ref<jclass> /*unused*/) {
   return inspectorFlags.getIsProfilingBuild();
 }
 
+bool JInspectorFlags::getFrameRecordingEnabled(
+    jni::alias_ref<jclass> /*unused*/) {
+  auto& inspectorFlags = InspectorFlags::getInstance();
+  return inspectorFlags.getFrameRecordingEnabled();
+}
+
 void JInspectorFlags::registerNatives() {
+  javaClassLocal()->registerNatives({
+      makeNativeMethod(
+          "getScreenshotCaptureEnabled",
+          JInspectorFlags::getScreenshotCaptureEnabled),
+  });
   javaClassLocal()->registerNatives({
       makeNativeMethod("getFuseboxEnabled", JInspectorFlags::getFuseboxEnabled),
   });
@@ -29,6 +46,11 @@ void JInspectorFlags::registerNatives() {
       makeNativeMethod(
           "getIsProfilingBuild", JInspectorFlags::getIsProfilingBuild),
   });
+  javaClassLocal()->registerNatives({
+      makeNativeMethod(
+          "getFrameRecordingEnabled",
+          JInspectorFlags::getFrameRecordingEnabled),
+  });
 }
 
 } // namespace facebook::react::jsinspector_modern

package/ReactAndroid/src/main/jni/react/devsupport/JInspectorFlags.h

@@ -18,8 +18,10 @@ class JInspectorFlags : public jni::JavaClass<JInspectorFlags> {
  public:
   static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/InspectorFlags;";
 
+  static bool getScreenshotCaptureEnabled(jni::alias_ref<jclass> /*unused*/);
   static bool getFuseboxEnabled(jni::alias_ref<jclass> /*unused*/);
   static bool getIsProfilingBuild(jni::alias_ref<jclass> /*unused*/);
+  static bool getFrameRecordingEnabled(jni::alias_ref<jclass> /*unused*/);
 
   static void registerNatives();
 

package/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<adc73df33ed2112584feaf83fb8d5e17>>
+ * @generated SignedSource<<d4aa5fd7828c31ac309551066662eeaa>>
  */
 
 /**
@@ -381,12 +381,24 @@ class ReactNativeFeatureFlagsJavaProvider
     return method(javaProvider_);
   }
 
+  bool fuseboxFrameRecordingEnabled() override {
+    static const auto method =
+        getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("fuseboxFrameRecordingEnabled");
+    return method(javaProvider_);
+  }
+
   bool fuseboxNetworkInspectionEnabled() override {
     static const auto method =
         getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("fuseboxNetworkInspectionEnabled");
     return method(javaProvider_);
   }
 
+  bool fuseboxScreenshotCaptureEnabled() override {
+    static const auto method =
+        getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("fuseboxScreenshotCaptureEnabled");
+    return method(javaProvider_);
+  }
+
   bool hideOffscreenVirtualViewsOnIOS() override {
     static const auto method =
         getReactNativeFeatureFlagsProviderJavaClass()->getMethod<jboolean()>("hideOffscreenVirtualViewsOnIOS");
@@ -838,11 +850,21 @@ bool JReactNativeFeatureFlagsCxxInterop::fuseboxEnabledRelease(
   return ReactNativeFeatureFlags::fuseboxEnabledRelease();
 }
 
+bool JReactNativeFeatureFlagsCxxInterop::fuseboxFrameRecordingEnabled(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
+  return ReactNativeFeatureFlags::fuseboxFrameRecordingEnabled();
+}
+
 bool JReactNativeFeatureFlagsCxxInterop::fuseboxNetworkInspectionEnabled(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
   return ReactNativeFeatureFlags::fuseboxNetworkInspectionEnabled();
 }
 
+bool JReactNativeFeatureFlagsCxxInterop::fuseboxScreenshotCaptureEnabled(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
+  return ReactNativeFeatureFlags::fuseboxScreenshotCaptureEnabled();
+}
+
 bool JReactNativeFeatureFlagsCxxInterop::hideOffscreenVirtualViewsOnIOS(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop> /*unused*/) {
   return ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS();
@@ -1180,9 +1202,15 @@ void JReactNativeFeatureFlagsCxxInterop::registerNatives() {
       makeNativeMethod(
         "fuseboxEnabledRelease",
         JReactNativeFeatureFlagsCxxInterop::fuseboxEnabledRelease),
+      makeNativeMethod(
+        "fuseboxFrameRecordingEnabled",
+        JReactNativeFeatureFlagsCxxInterop::fuseboxFrameRecordingEnabled),
       makeNativeMethod(
         "fuseboxNetworkInspectionEnabled",
         JReactNativeFeatureFlagsCxxInterop::fuseboxNetworkInspectionEnabled),
+      makeNativeMethod(
+        "fuseboxScreenshotCaptureEnabled",
+        JReactNativeFeatureFlagsCxxInterop::fuseboxScreenshotCaptureEnabled),
       makeNativeMethod(
         "hideOffscreenVirtualViewsOnIOS",
         JReactNativeFeatureFlagsCxxInterop::hideOffscreenVirtualViewsOnIOS),

package/ReactAndroid/src/main/jni/react/featureflags/JReactNativeFeatureFlagsCxxInterop.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<9853cf162b179249b2c6af120a662cf3>>
+ * @generated SignedSource<<554bd02cd328ba462d4e703b653d6cdd>>
  */
 
 /**
@@ -201,9 +201,15 @@ class JReactNativeFeatureFlagsCxxInterop
   static bool fuseboxEnabledRelease(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
+  static bool fuseboxFrameRecordingEnabled(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
+
   static bool fuseboxNetworkInspectionEnabled(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
 
+  static bool fuseboxScreenshotCaptureEnabled(
+    facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);
+
   static bool hideOffscreenVirtualViewsOnIOS(
     facebook::jni::alias_ref<JReactNativeFeatureFlagsCxxInterop>);