react-native-tvos 0.73.7-1 → 0.74.0-0

package/ReactAndroid/src/main/java/com/facebook/react/fabric/DevToolsReactPerfLogger.java

@@ -7,93 +7,30 @@
 
 package com.facebook.react.fabric;
 
-import static com.facebook.react.bridge.ReactMarkerConstants.*;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_BATCH_EXECUTION_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_BATCH_EXECUTION_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_COMMIT_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_COMMIT_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_DIFF_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_DIFF_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_FINISH_TRANSACTION_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_FINISH_TRANSACTION_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_LAYOUT_AFFECTED_NODES;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_LAYOUT_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_LAYOUT_START;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_START;
 
 import androidx.annotation.Nullable;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.ReactMarker;
 import com.facebook.react.bridge.ReactMarkerConstants;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.PriorityQueue;
-import java.util.Queue;
-
-class LongStreamingStats {
-  // TODO(T138627466): Calculate median value with better algorithm after Android API 24.
-  private Queue<Long> minHeap =
-      new PriorityQueue<>(
-          11,
-          new Comparator<Long>() {
-            @Override
-            public int compare(Long first, Long second) {
-              // Natural order
-              return Long.compare(first, second);
-            }
-          });
-  private Queue<Long> maxHeap =
-      new PriorityQueue<>(
-          11,
-          new Comparator<Long>() {
-            @Override
-            public int compare(Long first, Long second) {
-              // Reversed order
-              return Long.compare(second, first);
-            }
-          });
-  private double streamingAverage = 0.0;
-  private int len = 0;
-  private long max = 0;
-
-  LongStreamingStats() {}
-
-  public void add(long n) {
-    // To make medians more useful, we discard all zero values
-    // This isn't perfect and certainly makes this a totally invalid median, but, alas...
-    if (n != 0) {
-      if (minHeap.size() == maxHeap.size()) {
-        maxHeap.offer(n);
-        minHeap.offer(maxHeap.poll());
-      } else {
-        minHeap.offer(n);
-        maxHeap.offer(minHeap.poll());
-      }
-    }
-
-    len++;
-    if (len == 1) {
-      streamingAverage = n;
-    } else {
-      streamingAverage = (streamingAverage / (len / (len - 1))) + (n / len);
-    }
-
-    max = (n > max ? n : max);
-  }
-
-  public double getMedian() {
-    if (minHeap.size() == 0 && maxHeap.size() == 0) {
-      return 0;
-    }
-
-    long median;
-    if (minHeap.size() > maxHeap.size()) {
-      median = minHeap.peek();
-    } else {
-      median = (minHeap.peek() + maxHeap.peek()) / 2;
-    }
-    return median;
-  }
-
-  public double getAverage() {
-    return streamingAverage;
-  }
-
-  public long getMax() {
-    return max;
-  }
-}
 
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class DevToolsReactPerfLogger implements ReactMarker.FabricMarkerListener {
 
   private final Map<Integer, FabricCommitPoint> mFabricCommitMarkers = new HashMap<>();
@@ -116,8 +53,8 @@ public class DevToolsReactPerfLogger implements ReactMarker.FabricMarkerListener
     private final int mCounter;
 
     public FabricCommitPointData(long timeStamp, int counter) {
-      this.mTimeStamp = timeStamp;
-      this.mCounter = counter;
+      mTimeStamp = timeStamp;
+      mCounter = counter;
     }
 
     public long getTimeStamp() {
@@ -134,7 +71,7 @@ public class DevToolsReactPerfLogger implements ReactMarker.FabricMarkerListener
     private final Map<ReactMarkerConstants, FabricCommitPointData> mPoints = new HashMap<>();
 
     private FabricCommitPoint(int commitNumber) {
-      this.mCommitNumber = commitNumber;
+      mCommitNumber = commitNumber;
     }
 
     private void addPoint(ReactMarkerConstants key, FabricCommitPointData data) {
@@ -191,6 +128,10 @@ public class DevToolsReactPerfLogger implements ReactMarker.FabricMarkerListener
       return getCounter(FABRIC_LAYOUT_AFFECTED_NODES);
     }
 
+    public long getAffectedLayoutNodesCountTime() {
+      return getTimestamp(FABRIC_LAYOUT_AFFECTED_NODES);
+    }
+
     public long getBatchExecutionStart() {
       return getTimestamp(FABRIC_BATCH_EXECUTION_START);
     }
@@ -228,6 +169,7 @@ public class DevToolsReactPerfLogger implements ReactMarker.FabricMarkerListener
       return getBatchExecutionEnd() - getBatchExecutionStart();
     }
 
+    @Override
     public String toString() {
       StringBuilder builder = new StringBuilder("FabricCommitPoint{");
       builder.append("mCommitNumber=").append(mCommitNumber);

package/ReactAndroid/src/main/java/com/facebook/react/fabric/EmptyReactNativeConfig.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.fabric
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStripAny
+
+/**
+ * An empty [ReactNativeConfig] that is backed by the C++ implementation where the defaults are
+ * stored.
+ */
+@DoNotStripAny
+public class EmptyReactNativeConfig : ReactNativeConfig {
+  private val mHybridData: HybridData = initHybrid()
+
+  private external fun initHybrid(): HybridData
+
+  external override fun getBool(param: String): Boolean
+
+  external override fun getInt64(param: String): Long
+
+  external override fun getString(param: String): String
+
+  external override fun getDouble(param: String): Double
+
+  private companion object {
+    init {
+      FabricSoLoader.staticInit()
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricComponents.java

@@ -8,6 +8,7 @@
 package com.facebook.react.fabric;
 
 import androidx.annotation.NonNull;
+import com.facebook.infer.annotation.Nullsafe;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -17,6 +18,7 @@ import java.util.Map;
  * <p>TODO T97384889: remove this class when the component names are unified between JS - Android -
  * iOS - C++
  */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class FabricComponents {
 
   private static @NonNull final Map<String, String> sComponentNames = new HashMap<>();

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricSoLoader.java

@@ -9,11 +9,13 @@ package com.facebook.react.fabric;
 
 import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
 
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.ReactMarker;
 import com.facebook.react.bridge.ReactMarkerConstants;
 import com.facebook.soloader.SoLoader;
 import com.facebook.systrace.Systrace;
 
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class FabricSoLoader {
   private static volatile boolean sDidInit = false;
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManager.java

@@ -22,8 +22,6 @@ import static com.facebook.react.uimanager.common.UIManagerType.FABRIC;
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Point;
-import android.os.Handler;
-import android.os.Looper;
 import android.os.SystemClock;
 import android.view.View;
 import android.view.accessibility.AccessibilityEvent;
@@ -57,7 +55,9 @@ import com.facebook.react.common.mapbuffer.ReadableMapBuffer;
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.fabric.events.EventEmitterWrapper;
 import com.facebook.react.fabric.events.FabricEventEmitter;
-import com.facebook.react.fabric.interop.InteropEventEmitter;
+import com.facebook.react.fabric.internal.interop.InteropUIBlockListener;
+import com.facebook.react.fabric.interop.UIBlock;
+import com.facebook.react.fabric.interop.UIBlockViewResolver;
 import com.facebook.react.fabric.mounting.MountItemDispatcher;
 import com.facebook.react.fabric.mounting.MountingManager;
 import com.facebook.react.fabric.mounting.SurfaceMountingManager;
@@ -66,6 +66,7 @@ import com.facebook.react.fabric.mounting.mountitems.DispatchCommandMountItem;
 import com.facebook.react.fabric.mounting.mountitems.MountItem;
 import com.facebook.react.fabric.mounting.mountitems.MountItemFactory;
 import com.facebook.react.interfaces.fabric.SurfaceHandler;
+import com.facebook.react.internal.interop.InteropEventEmitter;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.uimanager.IllegalViewOperationException;
@@ -81,7 +82,6 @@ import com.facebook.react.uimanager.ViewManagerRegistry;
 import com.facebook.react.uimanager.events.BatchEventDispatchedListener;
 import com.facebook.react.uimanager.events.EventCategoryDef;
 import com.facebook.react.uimanager.events.EventDispatcher;
-import com.facebook.react.uimanager.events.EventDispatcherImpl;
 import com.facebook.react.uimanager.events.FabricEventDispatcher;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.facebook.react.views.text.TextLayoutManager;
@@ -100,7 +100,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  */
 @SuppressLint("MissingNativeLoadLibrary")
 @DoNotStripAny
-public class FabricUIManager implements UIManager, LifecycleEventListener {
+public class FabricUIManager implements UIManager, LifecycleEventListener, UIBlockViewResolver {
   public static final String TAG = FabricUIManager.class.getSimpleName();
 
   // The IS_DEVELOPMENT_ENVIRONMENT variable is used to log extra data when running fabric in a
@@ -175,7 +175,6 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   private final CopyOnWriteArrayList<UIManagerListener> mListeners = new CopyOnWriteArrayList<>();
 
   @NonNull private final AtomicBoolean mMountNotificationScheduled = new AtomicBoolean(false);
-  @NonNull private final Handler mMainThreadHandler = new Handler(Looper.getMainLooper());
 
   @ThreadConfined(UI)
   @NonNull
@@ -211,6 +210,10 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
         }
       };
 
+  // Interop UIManagerListener used to support addUIBlock and prependUIBlock.
+  // It's initialized only when addUIBlock or prependUIBlock is called the first time.
+  @Nullable private InteropUIBlockListener mInteropUIBlockListener;
+
   public FabricUIManager(
       @NonNull ReactApplicationContext reactContext,
       @NonNull ViewManagerRegistry viewManagerRegistry,
@@ -220,11 +223,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     mMountingManager = new MountingManager(viewManagerRegistry, mMountItemExecutor);
     mMountItemDispatcher =
         new MountItemDispatcher(mMountingManager, new MountItemDispatchListener());
-    if (ReactFeatureFlags.enableFabricSharedEventPipeline) {
-      mEventDispatcher = new FabricEventDispatcher(reactContext);
-    } else {
-      mEventDispatcher = new EventDispatcherImpl(reactContext);
-    }
+    mEventDispatcher = new FabricEventDispatcher(reactContext);
     mBatchEventDispatchedListener = batchEventDispatchedListener;
     mReactApplicationContext.addLifecycleEventListener(this);
 
@@ -232,13 +231,11 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     mReactApplicationContext.registerComponentCallbacks(viewManagerRegistry);
   }
 
-  // TODO (T47819352): Rename this to startSurface for consistency with xplat/iOS
   @Override
   @UiThread
   @ThreadConfined(UI)
   @Deprecated
-  public <T extends View> int addRootView(
-      final T rootView, final WritableMap initialProps, final @Nullable String initialUITemplate) {
+  public <T extends View> int addRootView(final T rootView, final WritableMap initialProps) {
     ReactSoftExceptionLogger.logSoftException(
         TAG,
         new IllegalViewOperationException(
@@ -256,9 +253,6 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       FLog.d(TAG, "Starting surface for module: %s and reactTag: %d", moduleName, rootTag);
     }
     mBinding.startSurface(rootTag, moduleName, (NativeMap) initialProps);
-    if (initialUITemplate != null) {
-      mBinding.renderTemplateToSurface(rootTag, initialUITemplate);
-    }
     return rootTag;
   }
 
@@ -407,12 +401,11 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     }
   }
 
-  // This is called on the JS thread (see CatalystInstanceImpl).
   @Override
   @AnyThread
   @ThreadConfined(ANY)
-  public void onCatalystInstanceDestroy() {
-    FLog.i(TAG, "FabricUIManager.onCatalystInstanceDestroy");
+  public void invalidate() {
+    FLog.i(TAG, "FabricUIManager.invalidate");
 
     if (mDevToolsReactPerfLogger != null) {
       mDevToolsReactPerfLogger.removeDevToolsReactPerfLoggerListener(FABRIC_PERF_LOGGER);
@@ -458,6 +451,37 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     }
   }
 
+  /**
+   * Method added to Fabric for backward compatibility reasons, as users on Paper could call
+   * [addUiBlock] and [prependUiBlock] on UIManagerModule.
+   */
+  public void addUIBlock(UIBlock block) {
+    if (ReactFeatureFlags.unstable_useFabricInterop) {
+      InteropUIBlockListener listener = getInteropUIBlockListener();
+      listener.addUIBlock(block);
+    }
+  }
+
+  /**
+   * Method added to Fabric for backward compatibility reasons, as users on Paper could call
+   * [addUiBlock] and [prependUiBlock] on UIManagerModule.
+   */
+  public void prependUIBlock(UIBlock block) {
+    if (ReactFeatureFlags.unstable_useFabricInterop) {
+      InteropUIBlockListener listener = getInteropUIBlockListener();
+      listener.prependUIBlock(block);
+    }
+  }
+
+  @NonNull
+  private InteropUIBlockListener getInteropUIBlockListener() {
+    if (mInteropUIBlockListener == null) {
+      mInteropUIBlockListener = new InteropUIBlockListener();
+      addUIManagerEventListener(mInteropUIBlockListener);
+    }
+    return mInteropUIBlockListener;
+  }
+
   @SuppressWarnings("unused")
   private NativeArray measureLines(
       ReadableMap attributedString, ReadableMap paragraphAttributes, float width, float height) {
@@ -624,10 +648,12 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
     return true;
   }
 
+  @Override
   public void addUIManagerEventListener(UIManagerListener listener) {
     mListeners.add(listener);
   }
 
+  @Override
   public void removeUIManagerEventListener(UIManagerListener listener) {
     mListeners.remove(listener);
   }
@@ -685,12 +711,11 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
             return View.NO_ID;
           }
 
+          @NonNull
           @Override
           public String toString() {
             String propsString =
-                IS_DEVELOPMENT_ENVIRONMENT
-                    ? (props != null ? props.toHashMap().toString() : "<null>")
-                    : "<hidden>";
+                IS_DEVELOPMENT_ENVIRONMENT ? props.toHashMap().toString() : "<hidden>";
             return String.format("SYNC UPDATE PROPS [%d]: %s", reactTag, propsString);
           }
         };
@@ -736,7 +761,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
             rootTag,
             reactTag,
             componentName,
-            props,
+            (ReadableMap) props,
             (StateWrapper) stateWrapper,
             (EventEmitterWrapper) eventEmitterWrapper,
             isLayoutable));
@@ -804,20 +829,6 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
           };
       if (UiThreadUtil.isOnUiThread()) {
         runnable.run();
-      } else {
-        // The Choreographer will dispatch any mount items,
-        // but it only gets called at the /beginning/ of the
-        // frame - it has no idea if, or when, there is actually work scheduled. That means if we
-        // have a big chunk of work
-        // scheduled but the scheduling happens 1ms after the
-        // start of a UI frame, we'll miss out on 15ms of time
-        // to perform the work (assuming a 16ms frame).
-        // The DispatchUIFrameCallback still has value because of
-        // the PreMountItems that we need to process at a lower
-        // priority.
-        if (ReactFeatureFlags.enableEarlyScheduledMountItemExecution) {
-          UiThreadUtil.runOnUiThread(runnable);
-        }
       }
     }
 
@@ -1028,7 +1039,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       final int reactTag,
       final int commandId,
       @Nullable final ReadableArray commandArgs) {
-    mMountItemDispatcher.dispatchCommandMountItem(
+    mMountItemDispatcher.addViewCommandMountItem(
         MountItemFactory.createDispatchCommandMountItem(
             surfaceId, reactTag, commandId, commandArgs));
   }
@@ -1044,10 +1055,10 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       // For Fabric Interop, we check if the commandId is an integer. If it is, we use the integer
       // overload of dispatchCommand. Otherwise, we use the string overload.
       // and the events won't be correctly dispatched.
-      mMountItemDispatcher.dispatchCommandMountItem(
+      mMountItemDispatcher.addViewCommandMountItem(
           createDispatchCommandMountItemForInterop(surfaceId, reactTag, commandId, commandArgs));
     } else {
-      mMountItemDispatcher.dispatchCommandMountItem(
+      mMountItemDispatcher.addViewCommandMountItem(
           MountItemFactory.createDispatchCommandMountItem(
               surfaceId, reactTag, commandId, commandArgs));
     }
@@ -1141,6 +1152,7 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
             return View.NO_ID;
           }
 
+          @NonNull
           @Override
           public String toString() {
             return "CLEAR_JS_RESPONDER";
@@ -1213,30 +1225,31 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       if (!mountNotificationScheduled) {
         // Notify mount when the effects are visible and prevent mount hooks to
         // delay paint.
-        mMainThreadHandler.postAtFrontOfQueue(
-            new Runnable() {
-              @Override
-              public void run() {
-                mMountNotificationScheduled.set(false);
-
-                final @Nullable Binding binding = mBinding;
-                if (mountItems == null || binding == null) {
-                  return;
-                }
-
-                // Collect surface IDs for all the mount items
-                List<Integer> surfaceIds = new ArrayList();
-                for (MountItem mountItem : mountItems) {
-                  if (mountItem != null && !surfaceIds.contains(mountItem.getSurfaceId())) {
-                    surfaceIds.add(mountItem.getSurfaceId());
+        UiThreadUtil.getUiThreadHandler()
+            .postAtFrontOfQueue(
+                new Runnable() {
+                  @Override
+                  public void run() {
+                    mMountNotificationScheduled.set(false);
+
+                    final @Nullable Binding binding = mBinding;
+                    if (mountItems == null || binding == null) {
+                      return;
+                    }
+
+                    // Collect surface IDs for all the mount items
+                    List<Integer> surfaceIds = new ArrayList<>();
+                    for (MountItem mountItem : mountItems) {
+                      if (mountItem != null && !surfaceIds.contains(mountItem.getSurfaceId())) {
+                        surfaceIds.add(mountItem.getSurfaceId());
+                      }
+                    }
+
+                    for (int surfaceId : surfaceIds) {
+                      binding.reportMount(surfaceId);
+                    }
                   }
-                }
-
-                for (int surfaceId : surfaceIds) {
-                  binding.reportMount(surfaceId);
-                }
-              }
-            });
+                });
       }
     }
 
@@ -1299,6 +1312,11 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
       }
 
       try {
+        // First, execute as many pre mount items as we can within frameTimeNanos time.
+        // If not all pre mount items were executed, following may happen:
+        //   1. In case there are view commands or mount items in MountItemDispatcher: execute
+        //   remaining pre mount items.
+        //   2. In case there are no view commands or mount items, wait until next frame.
         mMountItemDispatcher.dispatchPreMountItems(frameTimeNanos);
         mMountItemDispatcher.tryDispatchMountItems();
       } catch (Exception ex) {

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManagerProviderImpl.java

@@ -0,0 +1,65 @@
+/*
+ * 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.fabric;
+
+import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.bridge.UIManagerProvider;
+import com.facebook.react.fabric.events.EventBeatManager;
+import com.facebook.react.uimanager.ViewManagerRegistry;
+import com.facebook.systrace.Systrace;
+
+@Nullsafe(Nullsafe.Mode.LOCAL)
+public class FabricUIManagerProviderImpl implements UIManagerProvider {
+
+  private final ComponentFactory mComponentFactory;
+  private final ReactNativeConfig mConfig;
+  private final ViewManagerRegistry mViewManagerRegistry;
+
+  public FabricUIManagerProviderImpl(
+      ComponentFactory componentFactory,
+      ReactNativeConfig config,
+      ViewManagerRegistry viewManagerRegistry) {
+    mComponentFactory = componentFactory;
+    mConfig = config;
+    mViewManagerRegistry = viewManagerRegistry;
+  }
+
+  public UIManager createUIManager(ReactApplicationContext reactApplicationContext) {
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "FabricUIManagerProviderImpl.create");
+    EventBeatManager eventBeatManager = new EventBeatManager();
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "FabricUIManagerProviderImpl.createUIManager");
+
+    FabricUIManager fabricUIManager =
+        new FabricUIManager(reactApplicationContext, mViewManagerRegistry, eventBeatManager);
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "FabricUIManagerProviderImpl.registerBinding");
+    final Binding binding = new BindingImpl();
+
+    CatalystInstance catalystInstance = reactApplicationContext.getCatalystInstance();
+
+    binding.register(
+        catalystInstance.getRuntimeExecutor(),
+        catalystInstance.getRuntimeScheduler(),
+        fabricUIManager,
+        eventBeatManager,
+        mComponentFactory,
+        mConfig);
+
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+
+    return fabricUIManager;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/fabric/GuardedFrameCallback.java

@@ -7,12 +7,14 @@
 
 package com.facebook.react.fabric;
 
+import android.view.Choreographer;
 import androidx.annotation.NonNull;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.JSExceptionHandler;
 import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.modules.core.ChoreographerCompat;
 
-public abstract class GuardedFrameCallback extends ChoreographerCompat.FrameCallback {
+@Nullsafe(Nullsafe.Mode.LOCAL)
+public abstract class GuardedFrameCallback implements Choreographer.FrameCallback {
 
   @NonNull private final JSExceptionHandler mExceptionHandler;
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/LongStreamingStats.java

@@ -0,0 +1,76 @@
+/*
+ * 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.fabric;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+/* package */
+class LongStreamingStats {
+  // TODO(T138627466): Calculate median value with better algorithm after Android API 24.
+  private final Queue<Long> minHeap =
+      new PriorityQueue<>(11, Comparator.comparingLong(aLong -> aLong));
+  private final Queue<Long> maxHeap =
+      new PriorityQueue<>(
+          11,
+          (first, second) -> {
+            // Reversed order
+            return Long.compare(second, first);
+          });
+  private double streamingAverage = 0.0;
+  private int len = 0;
+  private long max = 0;
+
+  LongStreamingStats() {}
+
+  public void add(long n) {
+    // To make medians more useful, we discard all zero values
+    // This isn't perfect and certainly makes this a totally invalid median, but, alas...
+    if (n != 0) {
+      if (minHeap.size() == maxHeap.size()) {
+        maxHeap.offer(n);
+        minHeap.offer(maxHeap.poll());
+      } else {
+        minHeap.offer(n);
+        maxHeap.offer(minHeap.poll());
+      }
+    }
+
+    len++;
+    if (len == 1) {
+      streamingAverage = n;
+    } else {
+      streamingAverage = (streamingAverage / (len / (len - 1))) + (n / len);
+    }
+
+    max = (n > max ? n : max);
+  }
+
+  public double getMedian() {
+    if (minHeap.size() == 0 && maxHeap.size() == 0) {
+      return 0;
+    }
+
+    long median;
+    if (minHeap.size() > maxHeap.size()) {
+      median = minHeap.peek();
+    } else {
+      median = (minHeap.peek() + maxHeap.peek()) / 2;
+    }
+    return median;
+  }
+
+  public double getAverage() {
+    return streamingAverage;
+  }
+
+  public long getMax() {
+    return max;
+  }
+}