react-native 0.72.0-rc.0 → 0.72.0-rc.2

package/ReactAndroid/src/main/java/com/facebook/react/bridge/UIManagerListener.java

@@ -12,10 +12,33 @@ public interface UIManagerListener {
   /**
    * Called right before view updates are dispatched at the end of a batch. This is useful if a
    * module needs to add UIBlocks to the queue before it is flushed.
+   *
+   * <p>This is called by Paper only.
    */
   void willDispatchViewUpdates(UIManager uiManager);
-  /* Called right after view updates are dispatched for a frame. */
+  /**
+   * Called on UIThread right before view updates are executed.
+   *
+   * <p>This is called by Fabric only.
+   */
+  void willMountItems(UIManager uiManager);
+  /**
+   * Called on UIThread right after view updates are executed.
+   *
+   * <p>This is called by Fabric only.
+   */
+  void didMountItems(UIManager uiManager);
+  /**
+   * Called on UIThread right after view updates are dispatched for a frame. Note that this will be
+   * called for every frame even if there are no updates.
+   *
+   * <p>This is called by Fabric only.
+   */
   void didDispatchMountItems(UIManager uiManager);
-  /* Called right after scheduleMountItems is called in Fabric, after a new tree is committed. */
+  /**
+   * Called right after scheduleMountItems is called in Fabric, after a new tree is committed.
+   *
+   * <p>This is called by Fabric only.
+   */
   void didScheduleMountItems(UIManager uiManager);
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/interop/InteropModuleRegistry.java

@@ -0,0 +1,56 @@
+/*
+ * 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.bridge.interop;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.config.ReactFeatureFlags;
+import java.util.HashMap;
+
+/**
+ * A utility class that takes care of returning {@link JavaScriptModule} which are used for the
+ * Fabric Interop Layer. This allows us to override the returned classes once the user is invoking
+ * `ReactContext.getJsModule()`.
+ *
+ * <p>Currently we only support a `RCTEventEmitter` re-implementation, being `InteropEventEmitter`
+ * but this class can support other re-implementation in the future.
+ */
+public class InteropModuleRegistry {
+
+  @SuppressWarnings("rawtypes")
+  private final HashMap<Class, Object> supportedModules;
+
+  public InteropModuleRegistry() {
+    this.supportedModules = new HashMap<>();
+  }
+
+  public <T extends JavaScriptModule> boolean shouldReturnInteropModule(Class<T> requestedModule) {
+    return checkReactFeatureFlagsConditions() && supportedModules.containsKey(requestedModule);
+  }
+
+  @Nullable
+  public <T extends JavaScriptModule> T getInteropModule(Class<T> requestedModule) {
+    if (checkReactFeatureFlagsConditions()) {
+      //noinspection unchecked
+      return (T) supportedModules.get(requestedModule);
+    } else {
+      return null;
+    }
+  }
+
+  public <T extends JavaScriptModule> void registerInteropModule(
+      Class<T> interopModuleInterface, Object interopModule) {
+    if (checkReactFeatureFlagsConditions()) {
+      supportedModules.put(interopModuleInterface, interopModule);
+    }
+  }
+
+  private boolean checkReactFeatureFlagsConditions() {
+    return ReactFeatureFlags.enableFabricRenderer && ReactFeatureFlags.unstable_useFabricInterop;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/config/ReactFeatureFlags.java

@@ -34,6 +34,14 @@ public class ReactFeatureFlags {
    */
   public static volatile boolean enableFabricRenderer = false;
 
+  /**
+   * Should this application enable the Fabric Interop Layer for Android? If yes, the application
+   * will behave so that it can accept non-Fabric components and render them on Fabric. This toggle
+   * is controlling extra logic such as custom event dispatching that are needed for the Fabric
+   * Interop Layer to work correctly.
+   */
+  public static volatile boolean unstable_useFabricInterop = false;
+
   /**
    * Feature flag to enable the new bridgeless architecture. Note: Enabling this will force enable
    * the following flags: `useTurboModules` & `enableFabricRenderer`.
@@ -75,6 +83,9 @@ public class ReactFeatureFlags {
   /** Feature Flag to enable the pending event queue in fabric before mounting views */
   public static boolean enableFabricPendingEventQueue = false;
 
+  /** Feature Flag to enable caching mechanism of text measurement at shadow node level */
+  public static boolean enableTextMeasureCachePerShadowNode = false;
+
   /**
    * Feature flag that controls how turbo modules are exposed to JS
    *

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultNewArchitectureEntryPoint.kt

@@ -31,6 +31,7 @@ object DefaultNewArchitectureEntryPoint {
   ) {
     ReactFeatureFlags.useTurboModules = turboModulesEnabled
     ReactFeatureFlags.enableFabricRenderer = fabricEnabled
+    ReactFeatureFlags.unstable_useFabricInterop = fabricEnabled
 
     this.privateFabricEnabled = fabricEnabled
     this.privateTurboModulesEnabled = turboModulesEnabled

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultReactActivityDelegate.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react.defaults
 
+import android.os.Bundle
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
 import com.facebook.react.ReactRootView
@@ -43,4 +44,7 @@ open class DefaultReactActivityDelegate(
 
   override fun createRootView(): ReactRootView =
       ReactRootView(context).apply { setIsFabric(fabricEnabled) }
+
+  override fun createRootView(bundle: Bundle?): ReactRootView =
+      ReactRootView(context).apply { setIsFabric(fabricEnabled) }
 }

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

@@ -24,6 +24,7 @@ import android.util.Pair;
 import android.view.Gravity;
 import android.view.View;
 import android.widget.EditText;
+import android.widget.LinearLayout;
 import android.widget.TextView;
 import android.widget.Toast;
 import androidx.annotation.Nullable;
@@ -553,17 +554,30 @@ public abstract class DevSupportManagerBase implements DevSupportManager {
       return;
     }
 
-    final TextView textView = new TextView(getApplicationContext());
-    textView.setText("React Native DevMenu (" + getUniqueTag() + ")");
-    textView.setPadding(0, 50, 0, 0);
-    textView.setGravity(Gravity.CENTER);
-    textView.setTextColor(Color.BLACK);
-    textView.setTextSize(17);
-    textView.setTypeface(textView.getTypeface(), Typeface.BOLD);
+    final LinearLayout header = new LinearLayout(getApplicationContext());
+    header.setOrientation(LinearLayout.VERTICAL);
+
+    final TextView title = new TextView(getApplicationContext());
+    title.setText("React Native Dev Menu (" + getUniqueTag() + ")");
+    title.setPadding(0, 50, 0, 0);
+    title.setGravity(Gravity.CENTER);
+    title.setTextColor(Color.DKGRAY);
+    title.setTextSize(16);
+    title.setTypeface(title.getTypeface(), Typeface.BOLD);
+
+    final TextView jsExecutorLabel = new TextView(getApplicationContext());
+    jsExecutorLabel.setText(getJSExecutorDescription());
+    jsExecutorLabel.setPadding(0, 20, 0, 0);
+    jsExecutorLabel.setGravity(Gravity.CENTER);
+    jsExecutorLabel.setTextColor(Color.GRAY);
+    jsExecutorLabel.setTextSize(14);
+
+    header.addView(title);
+    header.addView(jsExecutorLabel);
 
     mDevOptionsDialog =
         new AlertDialog.Builder(context)
-            .setCustomTitle(textView)
+            .setCustomTitle(header)
             .setItems(
                 options.keySet().toArray(new String[0]),
                 new DialogInterface.OnClickListener() {
@@ -587,6 +601,10 @@ public abstract class DevSupportManagerBase implements DevSupportManager {
     }
   }
 
+  private String getJSExecutorDescription() {
+    return "Running " + getReactInstanceDevHelper().getJavaScriptExecutorFactory().toString();
+  }
+
   /**
    * {@link ReactInstanceDevCommandsHandler} is responsible for enabling/disabling dev support when
    * a React view is attached/detached or when application state changes (e.g. the application is

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

@@ -56,6 +56,7 @@ import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.fabric.events.EventBeatManager;
 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.mounting.MountItemDispatcher;
 import com.facebook.react.fabric.mounting.MountingManager;
 import com.facebook.react.fabric.mounting.SurfaceMountingManager;
@@ -81,6 +82,7 @@ import com.facebook.react.uimanager.ViewManagerRegistry;
 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.RCTEventEmitter;
 import com.facebook.react.views.text.TextLayoutManager;
 import com.facebook.react.views.text.TextLayoutManagerMapBuffer;
 import java.util.HashMap;
@@ -390,6 +392,11 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
 
       ReactMarker.addFabricListener(mDevToolsReactPerfLogger);
     }
+    if (ReactFeatureFlags.unstable_useFabricInterop) {
+      InteropEventEmitter interopEventEmitter = new InteropEventEmitter(mReactApplicationContext);
+      mReactApplicationContext.internal_registerInteropModule(
+          RCTEventEmitter.class, interopEventEmitter);
+    }
   }
 
   // This is called on the JS thread (see CatalystInstanceImpl).
@@ -1171,6 +1178,20 @@ public class FabricUIManager implements UIManager, LifecycleEventListener {
   }
 
   private class MountItemDispatchListener implements MountItemDispatcher.ItemDispatchListener {
+    @Override
+    public void willMountItems() {
+      for (UIManagerListener listener : mListeners) {
+        listener.willMountItems(FabricUIManager.this);
+      }
+    }
+
+    @Override
+    public void didMountItems() {
+      for (UIManagerListener listener : mListeners) {
+        listener.didMountItems(FabricUIManager.this);
+      }
+    }
+
     @Override
     public void didDispatchMountItems() {
       for (UIManagerListener listener : mListeners) {

package/ReactAndroid/src/main/java/com/facebook/react/fabric/interop/InteropEvent.java

@@ -0,0 +1,41 @@
+/*
+ * 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.interop;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.uimanager.events.Event;
+
+/**
+ * An {@link Event} class used by the {@link InteropEventEmitter}. This class is just holding the
+ * event name and the data which is received by the `receiveEvent` method and will be passed over
+ * the the {@link com.facebook.react.uimanager.events.EventDispatcher}
+ */
+class InteropEvent extends Event<InteropEvent> {
+
+  private final String mName;
+  private final WritableMap mEventData;
+
+  InteropEvent(String name, @Nullable WritableMap eventData, int surfaceId, int viewTag) {
+    super(surfaceId, viewTag);
+    mName = name;
+    mEventData = eventData;
+  }
+
+  @Override
+  public String getEventName() {
+    return mName;
+  }
+
+  @Override
+  @VisibleForTesting
+  public WritableMap getEventData() {
+    return mEventData;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/fabric/interop/InteropEventEmitter.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.interop;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+/**
+ * A reimplementation of {@link RCTEventEmitter} which is using a {@link EventDispatcher} under the
+ * hood.
+ *
+ * <p>On Fabric, you're supposed to use {@link EventDispatcher} to dispatch events. However, we
+ * provide an interop layer for non-Fabric migrated components.
+ *
+ * <p>This instance will be returned if the user is invoking `context.getJsModule(RCTEventEmitter)
+ * and is providing support for the `receiveEvent` method, so that non-Fabric ViewManagers can
+ * continue to deliver events also when Fabric is turned on.
+ */
+public class InteropEventEmitter implements RCTEventEmitter {
+
+  private final ReactContext mReactContext;
+
+  private @Nullable EventDispatcher mEventDispatcherOverride;
+
+  public InteropEventEmitter(ReactContext reactContext) {
+    mReactContext = reactContext;
+  }
+
+  @Override
+  public void receiveEvent(int targetReactTag, String eventName, @Nullable WritableMap eventData) {
+    EventDispatcher dispatcher;
+    if (mEventDispatcherOverride != null) {
+      dispatcher = mEventDispatcherOverride;
+    } else {
+      dispatcher = UIManagerHelper.getEventDispatcherForReactTag(mReactContext, targetReactTag);
+    }
+    int surfaceId = UIManagerHelper.getSurfaceId(mReactContext);
+    if (dispatcher != null) {
+      dispatcher.dispatchEvent(new InteropEvent(eventName, eventData, surfaceId, targetReactTag));
+    }
+  }
+
+  @Override
+  public void receiveTouches(
+      String eventName, WritableArray touches, WritableArray changedIndices) {
+    throw new UnsupportedOperationException(
+        "EventEmitter#receiveTouches is not supported by the Fabric Interop Layer");
+  }
+
+  @VisibleForTesting
+  void overrideEventDispatcher(EventDispatcher eventDispatcherOverride) {
+    mEventDispatcherOverride = eventDispatcherOverride;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/MountItemDispatcher.java

@@ -193,6 +193,8 @@ public class MountItemDispatcher {
       return false;
     }
 
+    mItemDispatchListener.willMountItems();
+
     // As an optimization, execute all ViewCommands first
     // This should be:
     // 1) Performant: ViewCommands are often a replacement for SetNativeProps, which we've always
@@ -299,6 +301,9 @@ public class MountItemDispatcher {
       }
       mBatchedExecutionTime += SystemClock.uptimeMillis() - batchedExecutionStartTime;
     }
+
+    mItemDispatchListener.didMountItems();
+
     Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
 
     return true;
@@ -415,6 +420,10 @@ public class MountItemDispatcher {
   }
 
   public interface ItemDispatchListener {
+    void willMountItems();
+
+    void didMountItems();
+
     void didDispatchMountItems();
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.java

@@ -18,5 +18,5 @@ public class ReactNativeVersion {
       "major", 0,
       "minor", 72,
       "patch", 0,
-      "prerelease", "rc.0");
+      "prerelease", "rc.2");
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ThemedReactContext.java

@@ -50,6 +50,7 @@ public class ThemedReactContext extends ReactContext {
     if (reactApplicationContext.hasCatalystInstance()) {
       initializeWithInstance(reactApplicationContext.getCatalystInstance());
     }
+    initializeInteropModules(reactApplicationContext);
     mReactApplicationContext = reactApplicationContext;
     mModuleName = moduleName;
     mSurfaceId = surfaceId;

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIManagerModuleConstantsHelper.java

@@ -10,11 +10,15 @@ package com.facebook.react.uimanager;
 import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
 
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
 import com.facebook.react.common.MapBuilder;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.systrace.SystraceMessage;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Helps generate constants map for {@link UIManagerModule} by collecting and merging constants from
@@ -113,6 +117,13 @@ import java.util.Map;
 
     Map viewManagerBubblingEvents = viewManager.getExportedCustomBubblingEventTypeConstants();
     if (viewManagerBubblingEvents != null) {
+
+      if (ReactFeatureFlags.enableFabricRenderer && ReactFeatureFlags.unstable_useFabricInterop) {
+        // For Fabric, events needs to be fired with a "top" prefix.
+        // For the sake of Fabric Interop, here we normalize events adding "top" in their
+        // name if the user hasn't provided it.
+        normalizeEventTypes(viewManagerBubblingEvents);
+      }
       recursiveMerge(cumulativeBubblingEventTypes, viewManagerBubblingEvents);
       recursiveMerge(viewManagerBubblingEvents, defaultBubblingEvents);
       viewManagerConstants.put(BUBBLING_EVENTS_KEY, viewManagerBubblingEvents);
@@ -145,6 +156,27 @@ import java.util.Map;
     return viewManagerConstants;
   }
 
+  @VisibleForTesting
+  /* package */ static void normalizeEventTypes(Map events) {
+    if (events == null) {
+      return;
+    }
+    Set<String> keysToNormalize = new HashSet<>();
+    for (Object key : events.keySet()) {
+      if (key instanceof String) {
+        String keyString = (String) key;
+        if (!keyString.startsWith("top")) {
+          keysToNormalize.add(keyString);
+        }
+      }
+    }
+    for (String oldKey : keysToNormalize) {
+      Object value = events.get(oldKey);
+      String newKey = "top" + oldKey.substring(0, 1).toUpperCase() + oldKey.substring(1);
+      events.put(newKey, value);
+    }
+  }
+
   /** Merges {@param source} map into {@param dest} map recursively */
   private static void recursiveMerge(@Nullable Map dest, @Nullable Map source) {
     if (dest == null || source == null || source.isEmpty()) {

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

@@ -18,6 +18,7 @@ import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UIManagerListener;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.common.ViewUtil;
 import com.facebook.react.views.scroll.ReactScrollViewHelper.HasSmoothScroll;
 import com.facebook.react.views.view.ReactViewGroup;
@@ -89,6 +90,14 @@ public class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup &
    * been updated.
    */
   public void updateScrollPosition() {
+    // On Fabric this will be called internally in `didMountItems`.
+    if (ViewUtil.getUIManagerType(mScrollView.getId()) == UIManagerType.FABRIC) {
+      return;
+    }
+    updateScrollPositionInternal();
+  }
+
+  private void updateScrollPositionInternal() {
     if (mConfig == null || mFirstVisibleView == null || mPrevFirstVisibleFrame == null) {
       return;
     }
@@ -169,6 +178,16 @@ public class MaintainVisibleScrollPositionHelper<ScrollViewT extends ViewGroup &
         });
   }
 
+  @Override
+  public void willMountItems(UIManager uiManager) {
+    computeTargetView();
+  }
+
+  @Override
+  public void didMountItems(UIManager uiManager) {
+    updateScrollPositionInternal();
+  }
+
   @Override
   public void didDispatchMountItems(UIManager uiManager) {
     // noop

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

@@ -37,6 +37,10 @@ public class CustomLetterSpacingSpan extends MetricAffectingSpan implements Reac
     apply(paint);
   }
 
+  public float getSpacing() {
+    return mLetterSpacing;
+  }
+
   private void apply(TextPaint paint) {
     if (!Float.isNaN(mLetterSpacing)) {
       paint.setLetterSpacing(mLetterSpacing);

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

@@ -71,6 +71,10 @@ public class CustomStyleSpan extends MetricAffectingSpan implements ReactSpan {
     return mFontFamily;
   }
 
+  public @Nullable String getFontFeatureSettings() {
+    return mFeatureSettings;
+  }
+
   private static void apply(
       Paint paint,
       int style,

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

@@ -31,8 +31,6 @@ public class ReactTextUpdate {
   private final int mSelectionEnd;
   private final int mJustificationMode;
 
-  public boolean mContainsMultipleFragments;
-
   /**
    * @deprecated Use a non-deprecated constructor for ReactTextUpdate instead. This one remains
    *     because it's being used by a unit test that isn't currently open source.
@@ -142,13 +140,11 @@ public class ReactTextUpdate {
       int jsEventCounter,
       int textAlign,
       int textBreakStrategy,
-      int justificationMode,
-      boolean containsMultipleFragments) {
+      int justificationMode) {
 
     ReactTextUpdate reactTextUpdate =
         new ReactTextUpdate(
             text, jsEventCounter, false, textAlign, textBreakStrategy, justificationMode);
-    reactTextUpdate.mContainsMultipleFragments = containsMultipleFragments;
     return reactTextUpdate;
   }