react-native-tvos 0.64.2-2 → 0.66.3-0

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

@@ -20,7 +20,7 @@ import com.facebook.react.bridge.CatalystInstance;
 import com.facebook.react.bridge.JSIModuleType;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -29,6 +29,7 @@ import com.facebook.react.uimanager.events.EventDispatcherProvider;
 /** Helper class for {@link UIManager}. */
 public class UIManagerHelper {
 
+  private static final String TAG = UIManagerHelper.class.getName();
   public static final int PADDING_START_INDEX = 0;
   public static final int PADDING_END_INDEX = 1;
   public static final int PADDING_TOP_INDEX = 2;
@@ -52,14 +53,10 @@ public class UIManagerHelper {
       @UIManagerType int uiManagerType,
       boolean returnNullIfCatalystIsInactive) {
     if (context.isBridgeless()) {
-      @Nullable
-      UIManager uiManager =
-          context.getJSIModule(JSIModuleType.UIManager) != null
-              ? (UIManager) context.getJSIModule(JSIModuleType.UIManager)
-              : null;
+      @Nullable UIManager uiManager = (UIManager) context.getJSIModule(JSIModuleType.UIManager);
       if (uiManager == null) {
-        ReactSoftException.logSoftException(
-            "UIManagerHelper",
+        ReactSoftExceptionLogger.logSoftException(
+            TAG,
             new ReactNoCrashSoftException(
                 "Cannot get UIManager because the instance hasn't been initialized yet."));
         return null;
@@ -68,17 +65,17 @@ public class UIManagerHelper {
     }
 
     if (!context.hasCatalystInstance()) {
-      ReactSoftException.logSoftException(
-          "UIManagerHelper",
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
           new ReactNoCrashSoftException(
               "Cannot get UIManager because the context doesn't contain a CatalystInstance."));
       return null;
     }
     // TODO T60461551: add tests to verify emission of events when the ReactContext is being turn
     // down.
-    if (!context.hasActiveCatalystInstance()) {
-      ReactSoftException.logSoftException(
-          "UIManagerHelper",
+    if (!context.hasActiveReactInstance()) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
           new ReactNoCrashSoftException(
               "Cannot get UIManager because the context doesn't contain an active CatalystInstance."));
       if (returnNullIfCatalystIsInactive) {
@@ -92,8 +89,8 @@ public class UIManagerHelper {
           : catalystInstance.getNativeModule(UIManagerModule.class);
     } catch (IllegalArgumentException ex) {
       // TODO T67518514 Clean this up once we migrate everything over to bridgeless mode
-      ReactSoftException.logSoftException(
-          "UIManagerHelper",
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
           new ReactNoCrashSoftException(
               "Cannot get UIManager for UIManagerType: " + uiManagerType));
       return catalystInstance.getNativeModule(UIManagerModule.class);
@@ -106,7 +103,12 @@ public class UIManagerHelper {
    */
   @Nullable
   public static EventDispatcher getEventDispatcherForReactTag(ReactContext context, int reactTag) {
-    return getEventDispatcher(context, getUIManagerType(reactTag));
+    EventDispatcher eventDispatcher = getEventDispatcher(context, getUIManagerType(reactTag));
+    if (eventDispatcher == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG, new IllegalStateException("Cannot get EventDispatcher for reactTag " + reactTag));
+    }
+    return eventDispatcher;
   }
 
   /**
@@ -124,7 +126,21 @@ public class UIManagerHelper {
       return ((EventDispatcherProvider) context).getEventDispatcher();
     }
     UIManager uiManager = getUIManager(context, uiManagerType, false);
-    return uiManager == null ? null : (EventDispatcher) uiManager.getEventDispatcher();
+    if (uiManager == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new ReactNoCrashSoftException(
+              "Unable to find UIManager for UIManagerType " + uiManagerType));
+      return null;
+    }
+    EventDispatcher eventDispatcher = (EventDispatcher) uiManager.getEventDispatcher();
+    if (eventDispatcher == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Cannot get EventDispatcher for UIManagerType " + uiManagerType));
+    }
+    return eventDispatcher;
   }
 
   /**
@@ -143,6 +159,42 @@ public class UIManagerHelper {
     return (ReactContext) context;
   }
 
+  /**
+   * @return Get the ThemedReactContext associated with a View, if possible, and then call
+   *     getSurfaceId on it. See above (getReactContext) for additional context.
+   */
+  public static int getSurfaceId(View view) {
+    int reactTag = view.getId();
+
+    // In non-Fabric we don't have (or use) SurfaceId
+    if (getUIManagerType(reactTag) == UIManagerType.DEFAULT) {
+      return -1;
+    }
+
+    Context context = view.getContext();
+    if (!(context instanceof ThemedReactContext) && context instanceof ContextWrapper) {
+      context = ((ContextWrapper) context).getBaseContext();
+    }
+
+    int surfaceId = getSurfaceId(context);
+
+    // All Fabric-managed Views (should) have a ThemedReactContext attached.
+    if (surfaceId == -1) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Fabric View [" + reactTag + "] does not have SurfaceId associated with it"));
+    }
+    return surfaceId;
+  }
+
+  public static int getSurfaceId(Context context) {
+    if (context instanceof ThemedReactContext) {
+      return ((ThemedReactContext) context).getSurfaceId();
+    }
+    return -1;
+  }
+
   /**
    * @return the default padding used by Android EditText's. This method returns the padding in an
    *     array to avoid extra classloading during hot-path of RN Android.

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

@@ -15,6 +15,7 @@ import static com.facebook.react.uimanager.common.UIManagerType.FABRIC;
 import android.content.ComponentCallbacks2;
 import android.content.res.Configuration;
 import android.view.View;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.collection.ArrayMap;
 import com.facebook.common.logging.FLog;
@@ -39,6 +40,7 @@ import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.common.ViewUtil;
 import com.facebook.react.uimanager.debug.NotThreadSafeViewHierarchyUpdateDebugListener;
@@ -85,21 +87,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
 @ReactModule(name = UIManagerModule.NAME)
 public class UIManagerModule extends ReactContextBaseJavaModule
     implements OnBatchCompleteListener, LifecycleEventListener, UIManager {
-
-  /** Enables lazy discovery of a specific {@link ViewManager} by its name. */
-  public interface ViewManagerResolver {
-    /**
-     * {@class UIManagerModule} class uses this method to get a ViewManager by its name. This is the
-     * same name that comes from JS by {@code UIManager.ViewManagerName} call.
-     */
-    @Nullable
-    ViewManager getViewManager(String viewManagerName);
-
-    /**
-     * Provides a list of view manager names to register in JS as {@code UIManager.ViewManagerName}
-     */
-    List<String> getViewManagerNames();
-  }
+  public static final String TAG = UIManagerModule.class.getSimpleName();
 
   /** Resolves a name coming from native side to a name of the event that is exposed to JS. */
   public interface CustomEventNamesResolver {
@@ -126,6 +114,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   private volatile int mViewManagerConstantsCacheSize;
 
   private int mBatchId = 0;
+  private int mNumRootViews = 0;
 
   @SuppressWarnings("deprecated")
   public UIManagerModule(
@@ -207,7 +196,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   }
 
   @Override
-  public String getName() {
+  public @NonNull String getName() {
     return NAME;
   }
 
@@ -242,8 +231,13 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   public void onCatalystInstanceDestroy() {
     super.onCatalystInstanceDestroy();
     mEventDispatcher.onCatalystInstanceDestroyed();
+    mUIImplementation.onCatalystInstanceDestroyed();
 
-    getReactApplicationContext().unregisterComponentCallbacks(mMemoryTrimCallback);
+    ReactApplicationContext reactApplicationContext = getReactApplicationContext();
+    if (ReactFeatureFlags.enableReactContextCleanupFix) {
+      reactApplicationContext.removeLifecycleEventListener(this);
+    }
+    reactApplicationContext.unregisterComponentCallbacks(mMemoryTrimCallback);
     YogaNodePool.get().clear();
     ViewManagerPropertyUpdater.clear();
   }
@@ -291,11 +285,22 @@ public class UIManagerModule extends ReactContextBaseJavaModule
    * Helper method to pre-compute the constants for a view manager. This method ensures that we
    * don't block for getting the constants for view managers during TTI
    *
-   * @deprecated this method will not be available in FabricUIManager class.
+   * @deprecated this method will be removed in the future
    * @param viewManagerNames {@link List<String>} names of ViewManagers
    */
   @Deprecated
-  public void preComputeConstantsForViewManager(List<String> viewManagerNames) {
+  @Override
+  public void preInitializeViewManagers(List<String> viewManagerNames) {
+    if (ReactFeatureFlags.enableExperimentalStaticViewConfigs) {
+      for (String viewManagerName : viewManagerNames) {
+        mUIImplementation.resolveViewManager(viewManagerName);
+      }
+      // When Static view configs are enabled it is not necessary to pre-compute the constants for
+      // viewManagers, although the pre-initialization of viewManager objects is still necessary
+      // for performance reasons.
+      return;
+    }
+
     Map<String, WritableMap> constantsMap = new ArrayMap<>();
     for (String viewManagerName : viewManagerNames) {
       WritableMap constants = computeConstantsForViewManager(viewManagerName);
@@ -406,22 +411,17 @@ public class UIManagerModule extends ReactContextBaseJavaModule
    */
   @Override
   public void synchronouslyUpdateViewOnUIThread(int tag, ReadableMap props) {
-    int uiManagerType = ViewUtil.getUIManagerType(tag);
-    if (uiManagerType == FABRIC) {
-      UIManager fabricUIManager =
-          UIManagerHelper.getUIManager(getReactApplicationContext(), uiManagerType);
-      if (fabricUIManager != null) {
-        fabricUIManager.synchronouslyUpdateViewOnUIThread(tag, props);
-      }
-    } else {
-      mUIImplementation.synchronouslyUpdateViewOnUIThread(tag, new ReactStylesDiffMap(props));
-    }
+    mUIImplementation.synchronouslyUpdateViewOnUIThread(tag, new ReactStylesDiffMap(props));
   }
 
   /**
    * Registers a new root view. JS can use the returned tag with manageChildren to add/remove
    * children to this view.
    *
+   * <p>Calling addRootView through UIManagerModule calls addRootView in the non-Fabric renderer,
+   * always. This is deprecated in favor of calling startSurface in Fabric, which must be done
+   * directly through the FabricUIManager.
+   *
    * <p>Note that this must be called after getWidth()/getHeight() actually return something. See
    * CatalystApplicationFragment as an example.
    *
@@ -433,11 +433,17 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "UIManagerModule.addRootView");
     final int tag = ReactRootViewTagGenerator.getNextRootViewTag();
     final ReactApplicationContext reactApplicationContext = getReactApplicationContext();
+
+    // We pass in a surfaceId of -1 here - it is used only in Fabric.
     final ThemedReactContext themedRootContext =
         new ThemedReactContext(
-            reactApplicationContext, rootView.getContext(), ((ReactRoot) rootView).getSurfaceID());
+            reactApplicationContext,
+            rootView.getContext(),
+            ((ReactRoot) rootView).getSurfaceID(),
+            -1);
 
     mUIImplementation.registerRootView(rootView, tag, themedRootContext);
+    mNumRootViews++;
     Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     return tag;
   }
@@ -461,6 +467,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   @ReactMethod
   public void removeRootView(int rootViewTag) {
     mUIImplementation.removeRootView(rootViewTag);
+    mNumRootViews--;
   }
 
   public void updateNodeSize(int nodeViewTag, int newWidth, int newHeight) {
@@ -509,25 +516,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
       FLog.d(ReactConstants.TAG, message);
       PrinterHolder.getPrinter().logMessage(ReactDebugOverlayTags.UI_MANAGER, message);
     }
-    int uiManagerType = ViewUtil.getUIManagerType(tag);
-    if (uiManagerType == FABRIC) {
-      ReactApplicationContext reactApplicationContext = getReactApplicationContext();
-      if (reactApplicationContext.hasActiveCatalystInstance()) {
-        final UIManager fabricUIManager =
-            UIManagerHelper.getUIManager(reactApplicationContext, uiManagerType);
-        if (fabricUIManager != null) {
-          reactApplicationContext.runOnUiQueueThread(
-              new Runnable() {
-                @Override
-                public void run() {
-                  fabricUIManager.synchronouslyUpdateViewOnUIThread(tag, props);
-                }
-              });
-        }
-      }
-    } else {
-      mUIImplementation.updateView(tag, className, props);
-    }
+    mUIImplementation.updateView(tag, className, props);
   }
 
   /**
@@ -710,8 +699,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   @ReactMethod
   public void dispatchViewManagerCommand(
       int reactTag, Dynamic commandId, @Nullable ReadableArray commandArgs) {
-    // TODO: this is a temporary approach to support ViewManagerCommands in Fabric until
-    // the dispatchViewManagerCommand() method is supported by Fabric JS API.
+    // Fabric dispatchCommands should go through the JSI API - this will crash in Fabric.
     @Nullable
     UIManager uiManager =
         UIManagerHelper.getUIManager(
@@ -820,7 +808,12 @@ public class UIManagerModule extends ReactContextBaseJavaModule
       listener.willDispatchViewUpdates(this);
     }
     try {
-      mUIImplementation.dispatchViewUpdates(batchId);
+      // If there are no RootViews registered, there will be no View updates to dispatch.
+      // This is a hack to prevent this from being called when Fabric is used everywhere.
+      // This should no longer be necessary in Bridgeless Mode.
+      if (mNumRootViews > 0) {
+        mUIImplementation.dispatchViewUpdates(batchId);
+      }
     } finally {
       Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     }
@@ -962,6 +955,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     public void onLowMemory() {}
   }
 
+  @Override
   public View resolveView(int tag) {
     UiThreadUtil.assertOnUiThread();
     return mUIImplementation
@@ -971,9 +965,16 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   }
 
   @Override
-  public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+  public void receiveEvent(int reactTag, String eventName, @Nullable WritableMap event) {
+    receiveEvent(-1, reactTag, eventName, event);
+  }
+
+  @Override
+  public void receiveEvent(
+      int surfaceId, int reactTag, String eventName, @Nullable WritableMap event) {
+    assert ViewUtil.getUIManagerType(reactTag) == DEFAULT;
     getReactApplicationContext()
         .getJSModule(RCTEventEmitter.class)
-        .receiveEvent(targetTag, eventName, event);
+        .receiveEvent(reactTag, eventName, event);
   }
 }

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

@@ -31,8 +31,7 @@ import java.util.Map;
    * UIManager.getViewManagerConfig('SpecificViewManager')} call happens. The View Manager is then
    * registered on the JS side with the help of {@code UIManagerModule.getConstantsForViewManager}.
    */
-  /* package */ static Map<String, Object> createConstants(
-      UIManagerModule.ViewManagerResolver resolver) {
+  /* package */ static Map<String, Object> createConstants(ViewManagerResolver resolver) {
     Map<String, Object> constants = UIManagerModuleConstants.getConstants();
     constants.put("ViewManagerNames", resolver.getViewManagerNames());
     constants.put("LazyViewManagersEnabled", true);

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

@@ -18,7 +18,7 @@ import com.facebook.react.bridge.GuardedRunnable;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.RetryableMountingLayerException;
@@ -118,7 +118,13 @@ public class UIViewOperationQueue {
         uiManager
             .getEventDispatcher()
             .dispatchEvent(
-                OnLayoutEvent.obtain(mTag, mScreenX, mScreenY, mScreenWidth, mScreenHeight));
+                OnLayoutEvent.obtain(
+                    -1 /* SurfaceId not used in classic renderer */,
+                    mTag,
+                    mScreenX,
+                    mScreenY,
+                    mScreenWidth,
+                    mScreenHeight));
       }
     }
   }
@@ -307,7 +313,7 @@ public class UIViewOperationQueue {
       try {
         mNativeViewHierarchyManager.dispatchCommand(mTag, mCommand, mArgs);
       } catch (Throwable e) {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG, new RuntimeException("Error dispatching View Command", e));
       }
     }
@@ -348,7 +354,7 @@ public class UIViewOperationQueue {
       try {
         mNativeViewHierarchyManager.dispatchCommand(mTag, mCommand, mArgs);
       } catch (Throwable e) {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG, new RuntimeException("Error dispatching View Command", e));
       }
     }
@@ -886,11 +892,12 @@ public class UIViewOperationQueue {
                         mViewCommandOperations.add(op);
                       } else {
                         // Retryable exceptions should be logged, but never crash in debug.
-                        ReactSoftException.logSoftException(TAG, new ReactNoCrashSoftException(e));
+                        ReactSoftExceptionLogger.logSoftException(
+                            TAG, new ReactNoCrashSoftException(e));
                       }
                     } catch (Throwable e) {
                       // Non-retryable exceptions should be logged in prod, and crash in Debug.
-                      ReactSoftException.logSoftException(TAG, e);
+                      ReactSoftExceptionLogger.logSoftException(TAG, e);
                     }
                   }
                 }

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

@@ -15,7 +15,6 @@ import com.facebook.react.bridge.BaseJavaModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.touch.JSResponderHandler;
 import com.facebook.react.touch.ReactInterceptingViewGroup;
 import com.facebook.react.uimanager.annotations.ReactProp;
@@ -39,11 +38,10 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
    *
    * @param viewToUpdate
    * @param props
-   * @param stateWrapper
    */
   public void updateProperties(@NonNull T viewToUpdate, ReactStylesDiffMap props) {
-    final ViewManagerDelegate<T> delegate;
-    if (ReactFeatureFlags.useViewManagerDelegates && (delegate = getDelegate()) != null) {
+    final ViewManagerDelegate<T> delegate = getDelegate();
+    if (delegate != null) {
       ViewManagerPropertyUpdater.updateProps(delegate, viewToUpdate, props);
     } else {
       ViewManagerPropertyUpdater.updateProps(this, viewToUpdate, props);
@@ -68,19 +66,14 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
     return null;
   }
 
-  /** Creates a view and installs event emitters on it. */
-  private final @NonNull T createView(
-      @NonNull ThemedReactContext reactContext, JSResponderHandler jsResponderHandler) {
-    return createView(reactContext, null, null, jsResponderHandler);
-  }
-
   /** Creates a view with knowledge of props and state. */
   public @NonNull T createView(
+      int reactTag,
       @NonNull ThemedReactContext reactContext,
       @Nullable ReactStylesDiffMap props,
       @Nullable StateWrapper stateWrapper,
       JSResponderHandler jsResponderHandler) {
-    T view = createViewInstance(reactContext, props, stateWrapper);
+    T view = createViewInstance(reactTag, reactContext, props, stateWrapper);
     if (view instanceof ReactInterceptingViewGroup) {
       ((ReactInterceptingViewGroup) view).setOnInterceptTouchEventListener(jsResponderHandler);
     }
@@ -128,19 +121,28 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
   /**
    * Subclasses should return a new View instance of the proper type. This is an optional method
    * that will call createViewInstance for you. Override it if you need props upon creation of the
-   * view.
+   * view, or state.
    *
-   * @param reactContext
+   * <p>If you override this method, you *must* guarantee that you you're handling updateProperties,
+   * view.setId, addEventEmitters, and updateState/updateExtraData properly!
+   *
+   * @param reactTag reactTag that should be set as ID of the view instance
+   * @param reactContext ReactContext used to initialize view instance
+   * @param initialProps initial props for the view instance
+   * @param stateWrapper initial state for the view instance
    */
   protected @NonNull T createViewInstance(
+      int reactTag,
       @NonNull ThemedReactContext reactContext,
       @Nullable ReactStylesDiffMap initialProps,
       @Nullable StateWrapper stateWrapper) {
     T view = createViewInstance(reactContext);
+    view.setId(reactTag);
     addEventEmitters(reactContext, view);
     if (initialProps != null) {
       updateProperties(view, initialProps);
     }
+    // Only present in Fabric; but always present in Fabric.
     if (stateWrapper != null) {
       Object extraData = updateState(view, initialProps, stateWrapper);
       if (extraData != null) {

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

@@ -19,9 +19,9 @@ import java.util.Map;
 public final class ViewManagerRegistry {
 
   private final Map<String, ViewManager> mViewManagers;
-  private final @Nullable UIManagerModule.ViewManagerResolver mViewManagerResolver;
+  private final @Nullable ViewManagerResolver mViewManagerResolver;
 
-  public ViewManagerRegistry(UIManagerModule.ViewManagerResolver viewManagerResolver) {
+  public ViewManagerRegistry(ViewManagerResolver viewManagerResolver) {
     mViewManagers = MapBuilder.newHashMap();
     mViewManagerResolver = viewManagerResolver;
   }

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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.uimanager;
+
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Enables lazy discovery of a specific {@link ViewManager} by its name. */
+public interface ViewManagerResolver {
+  /**
+   * {@class UIManagerModule} class uses this method to get a ViewManager by its name. This is the
+   * same name that comes from JS by {@code UIManager.ViewManagerName} call.
+   */
+  @Nullable
+  ViewManager getViewManager(String viewManagerName);
+
+  /**
+   * Provides a list of view manager names to register in JS as {@code UIManager.ViewManagerName}
+   */
+  List<String> getViewManagerNames();
+}

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

@@ -325,6 +325,21 @@ import java.util.Map;
     }
   }
 
+  private static class BoxedColorPropSetter extends PropSetter {
+
+    public BoxedColorPropSetter(ReactProp prop, Method setter) {
+      super(prop, "mixed", setter);
+    }
+
+    @Override
+    protected @Nullable Object getValueOrDefault(Object value, Context context) {
+      if (value != null) {
+        return ColorPropConverter.getColor(value, context);
+      }
+      return null;
+    }
+  }
+
   /*package*/ static Map<String, String> getNativePropsForView(
       Class<? extends ViewManager> viewManagerTopClass,
       Class<? extends ReactShadowNode> shadowNodeTopClass) {
@@ -418,7 +433,7 @@ import java.util.Map;
       return new BoxedBooleanPropSetter(annotation, method);
     } else if (propTypeClass == Integer.class) {
       if ("Color".equals(annotation.customType())) {
-        return new ColorPropSetter(annotation, method);
+        return new BoxedColorPropSetter(annotation, method);
       }
       return new BoxedIntPropSetter(annotation, method);
     } else if (propTypeClass == ReadableArray.class) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/annotations/BUCK

@@ -3,6 +3,7 @@ load("//tools/build_defs/oss:rn_defs.bzl", "react_native_dep", "rn_android_libra
 rn_android_library(
     name = "annotations",
     srcs = glob(["*.java"]),
+    autoglob = False,
     is_androidx = True,
     labels = ["supermodule:xplat/default/public.react_native.infra"],
     required_for_source_only_abi = True,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/common/BUCK

@@ -3,6 +3,7 @@ load("//tools/build_defs/oss:rn_defs.bzl", "react_native_dep", "rn_android_libra
 rn_android_library(
     name = "common",
     srcs = glob(["*.java"]),
+    autoglob = False,
     is_androidx = True,
     labels = ["supermodule:xplat/default/public.react_native.infra"],
     provided_deps = [
@@ -17,7 +18,6 @@ rn_android_library(
         "PUBLIC",
     ],
     deps = [
-        # react_native_dep("third-party/android/androidx:appcompat"),
         react_native_dep("third-party/java/jsr-305:jsr-305"),
     ],
 )

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/BlackHoleEventDispatcher.java

@@ -49,6 +49,9 @@ public class BlackHoleEventDispatcher implements EventDispatcher {
   @Override
   public void registerEventEmitter(int uiManagerType, RCTEventEmitter eventEmitter) {}
 
+  @Override
+  public void registerEventEmitter(int uiManagerType, RCTModernEventEmitter eventEmitter) {}
+
   @Override
   public void unregisterEventEmitter(int uiManagerType) {}
 

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/ContentSizeChangeEvent.java

@@ -19,8 +19,13 @@ public class ContentSizeChangeEvent extends Event<ContentSizeChangeEvent> {
   private final int mWidth;
   private final int mHeight;
 
+  @Deprecated
   public ContentSizeChangeEvent(int viewTag, int width, int height) {
-    super(viewTag);
+    this(-1, viewTag, width, height);
+  }
+
+  public ContentSizeChangeEvent(int surfaceId, int viewTag, int width, int height) {
+    super(surfaceId, viewTag);
     mWidth = width;
     mHeight = height;
   }
@@ -31,10 +36,10 @@ public class ContentSizeChangeEvent extends Event<ContentSizeChangeEvent> {
   }
 
   @Override
-  public void dispatch(RCTEventEmitter rctEventEmitter) {
+  protected WritableMap getEventData() {
     WritableMap data = Arguments.createMap();
     data.putDouble("width", PixelUtil.toDIPFromPixel(mWidth));
     data.putDouble("height", PixelUtil.toDIPFromPixel(mHeight));
-    rctEventEmitter.receiveEvent(getViewTag(), EVENT_NAME, data);
+    return data;
   }
 }