react-native 0.0.0-e6fc20ee6 → 0.0.0-e9440508e-20211011-2008

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;
@@ -51,18 +52,30 @@ public class UIManagerHelper {
       ReactContext context,
       @UIManagerType int uiManagerType,
       boolean returnNullIfCatalystIsInactive) {
+    if (context.isBridgeless()) {
+      @Nullable UIManager uiManager = (UIManager) context.getJSIModule(JSIModuleType.UIManager);
+      if (uiManager == null) {
+        ReactSoftExceptionLogger.logSoftException(
+            TAG,
+            new ReactNoCrashSoftException(
+                "Cannot get UIManager because the instance hasn't been initialized yet."));
+        return null;
+      }
+      return uiManager;
+    }
+
     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) {
@@ -70,9 +83,18 @@ public class UIManagerHelper {
       }
     }
     CatalystInstance catalystInstance = context.getCatalystInstance();
-    return uiManagerType == FABRIC
-        ? (UIManager) catalystInstance.getJSIModule(JSIModuleType.UIManager)
-        : catalystInstance.getNativeModule(UIManagerModule.class);
+    try {
+      return uiManagerType == FABRIC
+          ? (UIManager) catalystInstance.getJSIModule(JSIModuleType.UIManager)
+          : catalystInstance.getNativeModule(UIManagerModule.class);
+    } catch (IllegalArgumentException ex) {
+      // TODO T67518514 Clean this up once we migrate everything over to bridgeless mode
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new ReactNoCrashSoftException(
+              "Cannot get UIManager for UIManagerType: " + uiManagerType));
+      return catalystInstance.getNativeModule(UIManagerModule.class);
+    }
   }
 
   /**
@@ -81,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;
   }
 
   /**
@@ -99,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;
   }
 
   /**
@@ -118,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;
@@ -51,6 +53,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
  * Native module to allow JS to create and update native Views.
@@ -84,21 +87,7 @@ import java.util.Map;
 @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 {
@@ -119,11 +108,13 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   private final UIImplementation mUIImplementation;
   private final MemoryTrimCallback mMemoryTrimCallback = new MemoryTrimCallback();
   private final List<UIManagerModuleListener> mListeners = new ArrayList<>();
-  private final List<UIManagerListener> mUIManagerListeners = new ArrayList<>();
+  private final CopyOnWriteArrayList<UIManagerListener> mUIManagerListeners =
+      new CopyOnWriteArrayList<>();
   private @Nullable Map<String, WritableMap> mViewManagerConstantsCache;
   private volatile int mViewManagerConstantsCacheSize;
 
   private int mBatchId = 0;
+  private int mNumRootViews = 0;
 
   @SuppressWarnings("deprecated")
   public UIManagerModule(
@@ -196,13 +187,16 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   /**
    * This method gives an access to the {@link UIImplementation} object that can be used to execute
    * operations on the view hierarchy.
+   *
+   * @deprecated This method will not be supported by the new architecture of react native.
    */
+  @Deprecated
   public UIImplementation getUIImplementation() {
     return mUIImplementation;
   }
 
   @Override
-  public String getName() {
+  public @NonNull String getName() {
     return NAME;
   }
 
@@ -237,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();
   }
@@ -286,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);
@@ -355,20 +365,30 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   }
 
   /** Resolves Direct Event name exposed to JS from the one known to the Native side. */
+  @Deprecated
   public CustomEventNamesResolver getDirectEventNamesResolver() {
     return new CustomEventNamesResolver() {
       @Override
-      public @Nullable String resolveCustomEventName(String eventName) {
-        Map<String, String> customEventType =
-            (Map<String, String>) mCustomDirectEvents.get(eventName);
-        if (customEventType != null) {
-          return customEventType.get("registrationName");
-        }
-        return eventName;
+      public @Nullable String resolveCustomEventName(@Nullable String eventName) {
+        return resolveCustomDirectEventName(eventName);
       }
     };
   }
 
+  @Override
+  @Deprecated
+  @Nullable
+  public String resolveCustomDirectEventName(@Nullable String eventName) {
+    if (eventName != null) {
+      Map<String, String> customEventType =
+          (Map<String, String>) mCustomDirectEvents.get(eventName);
+      if (customEventType != null) {
+        return customEventType.get("registrationName");
+      }
+    }
+    return eventName;
+  }
+
   @Override
   public void profileNextBatch() {
     mUIImplementation.profileNextBatch();
@@ -391,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.
    *
@@ -418,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;
   }
@@ -446,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) {
@@ -494,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);
   }
 
   /**
@@ -695,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(
@@ -805,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);
     }
@@ -911,10 +919,14 @@ public class UIManagerModule extends ReactContextBaseJavaModule
 
   /**
    * Updates the styles of the {@link ReactShadowNode} based on the Measure specs received by
-   * parameters.
+   * parameters. offsetX and offsetY aren't used in non-Fabric, so they're ignored here.
    */
   public void updateRootLayoutSpecs(
-      final int rootViewTag, final int widthMeasureSpec, final int heightMeasureSpec) {
+      final int rootViewTag,
+      final int widthMeasureSpec,
+      final int heightMeasureSpec,
+      int offsetX,
+      int offsetY) {
     ReactApplicationContext reactApplicationContext = getReactApplicationContext();
     reactApplicationContext.runOnNativeModulesQueueThread(
         new GuardedRunnable(reactApplicationContext) {
@@ -943,6 +955,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     public void onLowMemory() {}
   }
 
+  @Override
   public View resolveView(int tag) {
     UiThreadUtil.assertOnUiThread();
     return mUIImplementation
@@ -952,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,14 +18,13 @@ 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;
 import com.facebook.react.bridge.SoftAssertions;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.uimanager.debug.NotThreadSafeViewHierarchyUpdateDebugListener;
 import com.facebook.systrace.Systrace;
@@ -119,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));
       }
     }
   }
@@ -308,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));
       }
     }
@@ -349,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));
       }
     }
@@ -596,7 +601,6 @@ public class UIViewOperationQueue {
   private final DispatchUIFrameCallback mDispatchUIFrameCallback;
   private final ReactApplicationContext mReactApplicationContext;
 
-  private final boolean mAllowViewCommandsQueue;
   private ArrayList<DispatchCommandViewOperation> mViewCommandOperations = new ArrayList<>();
 
   // Only called from the UIManager queue?
@@ -637,7 +641,6 @@ public class UIViewOperationQueue {
                 ? DEFAULT_MIN_TIME_LEFT_IN_FRAME_FOR_NONBATCHED_OPERATION_MS
                 : minTimeLeftInFrameForNonBatchedOperationMs);
     mReactApplicationContext = reactContext;
-    mAllowViewCommandsQueue = ReactFeatureFlags.allowEarlyViewCommandExecution;
   }
 
   /*package*/ NativeViewHierarchyManager getNativeViewHierarchyManager() {
@@ -709,22 +712,14 @@ public class UIViewOperationQueue {
       int reactTag, int commandId, @Nullable ReadableArray commandArgs) {
     final DispatchCommandOperation command =
         new DispatchCommandOperation(reactTag, commandId, commandArgs);
-    if (mAllowViewCommandsQueue) {
-      mViewCommandOperations.add(command);
-    } else {
-      mOperations.add(command);
-    }
+    mViewCommandOperations.add(command);
   }
 
   public void enqueueDispatchCommand(
       int reactTag, String commandId, @Nullable ReadableArray commandArgs) {
     final DispatchStringCommandOperation command =
         new DispatchStringCommandOperation(reactTag, commandId, commandArgs);
-    if (mAllowViewCommandsQueue) {
-      mViewCommandOperations.add(command);
-    } else {
-      mOperations.add(command);
-    }
+    mViewCommandOperations.add(command);
   }
 
   public void enqueueUpdateExtraData(int reactTag, Object extraData) {
@@ -877,8 +872,7 @@ public class UIViewOperationQueue {
                 long runStartTime = SystemClock.uptimeMillis();
 
                 // All ViewCommands should be executed first as a perf optimization.
-                // This entire block is only executed if there's a separate viewCommand queue,
-                // which is currently gated by a ReactFeatureFlag.
+                // This entire block is only executed if there's at least one ViewCommand queued.
                 if (viewCommandOperations != null) {
                   for (DispatchCommandViewOperation op : viewCommandOperations) {
                     try {
@@ -898,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) {
@@ -269,6 +271,10 @@ public abstract class ViewManager<T extends View, C extends ReactShadowNode>
     return null;
   }
 
+  /**
+   * Returns a {@link Map<String, String>} representing the native props of the view manager. The
+   * Map contains the names (key) and types (value) of the ViewManager's props.
+   */
   public Map<String, String> getNativeProps() {
     return ViewManagerPropertyUpdater.getNativeProps(getClass(), getShadowNodeClass());
   }