react-native 0.70.4 → 0.71.0-rc.0

package/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerBuilder.java

@@ -14,6 +14,7 @@ import android.app.Activity;
 import android.app.Application;
 import android.content.Context;
 import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
 import com.facebook.hermes.reactexecutor.HermesExecutor;
 import com.facebook.hermes.reactexecutor.HermesExecutorFactory;
 import com.facebook.infer.annotation.Assertions;
@@ -33,7 +34,6 @@ import com.facebook.react.jscexecutor.JSCExecutor;
 import com.facebook.react.jscexecutor.JSCExecutorFactory;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.packagerconnection.RequestHandler;
-import com.facebook.react.uimanager.UIImplementationProvider;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -41,6 +41,8 @@ import java.util.Map;
 /** Builder class for {@link ReactInstanceManager} */
 public class ReactInstanceManagerBuilder {
 
+  private static final String TAG = ReactInstanceManagerBuilder.class.getSimpleName();
+
   private final List<ReactPackage> mPackages = new ArrayList<>();
 
   private @Nullable String mJSBundleAssetUrl;
@@ -52,7 +54,6 @@ public class ReactInstanceManagerBuilder {
   private @Nullable DevSupportManagerFactory mDevSupportManagerFactory;
   private boolean mRequireActivity;
   private @Nullable LifecycleState mInitialLifecycleState;
-  private @Nullable UIImplementationProvider mUIImplementationProvider;
   private @Nullable JSExceptionHandler mJSExceptionHandler;
   private @Nullable Activity mCurrentActivity;
   private @Nullable DefaultHardwareBackBtnHandler mDefaultHardwareBackBtnHandler;
@@ -66,17 +67,10 @@ public class ReactInstanceManagerBuilder {
   private @Nullable Map<String, RequestHandler> mCustomPackagerCommandHandlers;
   private @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
   private @Nullable SurfaceDelegateFactory mSurfaceDelegateFactory;
-  private JSInterpreter jsInterpreter = JSInterpreter.OLD_LOGIC;
+  private JSEngineResolutionAlgorithm jsEngineResolutionAlgorithm = null;
 
   /* package protected */ ReactInstanceManagerBuilder() {}
 
-  /** Sets a provider of {@link UIImplementation}. Uses default provider if null is passed. */
-  public ReactInstanceManagerBuilder setUIImplementationProvider(
-      @Nullable UIImplementationProvider uiImplementationProvider) {
-    mUIImplementationProvider = uiImplementationProvider;
-    return this;
-  }
-
   public ReactInstanceManagerBuilder setJSIModulesPackage(
       @Nullable JSIModulePackage jsiModulePackage) {
     mJSIModulesPackage = jsiModulePackage;
@@ -127,28 +121,12 @@ public class ReactInstanceManagerBuilder {
   }
 
   /**
-   * Sets the jsEngine as JSC or HERMES as per the setJsEngineAsHermes call Uses the enum {@link
-   * JSInterpreter}
-   *
-   * @param jsInterpreter
+   * Sets the JS Engine to load as either Hermes or JSC. If not set, the default is JSC with a
+   * Hermes fallback.
    */
-  private void setJSEngine(JSInterpreter jsInterpreter) {
-    this.jsInterpreter = jsInterpreter;
-  }
-
-  /**
-   * Utility setter to set the required JSEngine as HERMES or JSC Defaults to OLD_LOGIC if not
-   * called by the host app
-   *
-   * @param hermesEnabled hermesEnabled = true sets the JS Engine as HERMES and JSC otherwise
-   */
-  public ReactInstanceManagerBuilder setJsEngineAsHermes(boolean hermesEnabled) {
-    if (hermesEnabled) {
-      setJSEngine(JSInterpreter.HERMES);
-    } else {
-      setJSEngine(JSInterpreter.JSC);
-    }
-    return this;
+  private void setJSEngineResolutionAlgorithm(
+      @Nullable JSEngineResolutionAlgorithm jsEngineResolutionAlgorithm) {
+    this.jsEngineResolutionAlgorithm = jsEngineResolutionAlgorithm;
   }
 
   /**
@@ -325,11 +303,6 @@ public class ReactInstanceManagerBuilder {
         mJSMainModulePath != null || mJSBundleAssetUrl != null || mJSBundleLoader != null,
         "Either MainModulePath or JS Bundle File needs to be provided");
 
-    if (mUIImplementationProvider == null) {
-      // create default UIImplementationProvider if the provided one is null.
-      mUIImplementationProvider = new UIImplementationProvider();
-    }
-
     // We use the name of the device and the app for debugging & metrics
     //noinspection ConstantConditions
     String appName = mApplication.getPackageName();
@@ -355,7 +328,6 @@ public class ReactInstanceManagerBuilder {
         mRequireActivity,
         mBridgeIdleDebugListener,
         Assertions.assertNotNull(mInitialLifecycleState, "Initial lifecycle state was not set"),
-        mUIImplementationProvider,
         mJSExceptionHandler,
         mRedBoxHandler,
         mLazyViewManagersEnabled,
@@ -380,7 +352,11 @@ public class ReactInstanceManagerBuilder {
 
     // if nothing is specified, use old loading method
     // else load the required engine
-    if (jsInterpreter == JSInterpreter.OLD_LOGIC) {
+    if (jsEngineResolutionAlgorithm == null) {
+      FLog.w(
+          TAG,
+          "You're not setting the JS Engine Resolution Algorithm. "
+              + "We'll try to load JSC first, and if it fails we'll fallback to Hermes");
       try {
         // If JSC is included, use it as normal
         initializeSoLoaderIfNecessary(applicationContext);
@@ -393,7 +369,7 @@ public class ReactInstanceManagerBuilder {
         HermesExecutor.loadLibrary();
         return new HermesExecutorFactory();
       }
-    } else if (jsInterpreter == JSInterpreter.HERMES) {
+    } else if (jsEngineResolutionAlgorithm == JSEngineResolutionAlgorithm.HERMES) {
       HermesExecutor.loadLibrary();
       return new HermesExecutorFactory();
     } else {

package/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java

@@ -19,7 +19,6 @@ import com.facebook.react.common.SurfaceDelegate;
 import com.facebook.react.common.SurfaceDelegateFactory;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.interfaces.RedBoxHandler;
-import com.facebook.react.uimanager.UIImplementationProvider;
 import java.util.List;
 
 /**
@@ -77,7 +76,6 @@ public abstract class ReactNativeHost {
             .setLazyViewManagersEnabled(getLazyViewManagersEnabled())
             .setRedBoxHandler(getRedBoxHandler())
             .setJavaScriptExecutorFactory(getJavaScriptExecutorFactory())
-            .setUIImplementationProvider(getUIImplementationProvider())
             .setJSIModulesPackage(getJSIModulePackage())
             .setInitialLifecycleState(LifecycleState.BEFORE_CREATE)
             .setReactPackageTurboModuleManagerDelegateBuilder(
@@ -117,16 +115,6 @@ public abstract class ReactNativeHost {
     return mApplication;
   }
 
-  /**
-   * Get the {@link UIImplementationProvider} to use. Override this method if you want to use a
-   * custom UI implementation.
-   *
-   * <p>Note: this is very advanced functionality, in 99% of cases you don't need to override this.
-   */
-  protected UIImplementationProvider getUIImplementationProvider() {
-    return new UIImplementationProvider();
-  }
-
   protected @Nullable JSIModulePackage getJSIModulePackage() {
     return null;
   }
@@ -202,4 +190,12 @@ public abstract class ReactNativeHost {
    * default ones, you'll want to include more packages here.
    */
   protected abstract List<ReactPackage> getPackages();
+
+  /**
+   * Returns the {@link JSEngineResolutionAlgorithm} to be used when loading the JS engine. If null,
+   * will try to load JSC first and fallback to Hermes if JSC is not available.
+   */
+  protected @Nullable JSEngineResolutionAlgorithm getJSEngineResolutionAlgorithm() {
+    return null;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java

@@ -12,6 +12,7 @@ import static com.facebook.react.uimanager.common.UIManagerType.DEFAULT;
 import static com.facebook.react.uimanager.common.UIManagerType.FABRIC;
 import static com.facebook.systrace.Systrace.TRACE_TAG_REACT_JAVA_BRIDGE;
 
+import android.app.Activity;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Point;
@@ -31,6 +32,9 @@ import android.view.WindowInsets;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.graphics.Insets;
+import androidx.core.view.WindowInsetsCompat;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.ThreadConfined;
@@ -58,6 +62,7 @@ import com.facebook.react.uimanager.JSTouchDispatcher;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.ReactClippingProhibitedView;
 import com.facebook.react.uimanager.ReactRoot;
+import com.facebook.react.uimanager.ReactRootViewTagGenerator;
 import com.facebook.react.uimanager.RootView;
 import com.facebook.react.uimanager.RootViewUtil;
 import com.facebook.react.uimanager.UIManagerHelper;
@@ -127,6 +132,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   }
 
   private void init() {
+    setRootViewTag(ReactRootViewTagGenerator.getNextRootViewTag());
     setClipChildren(false);
   }
 
@@ -770,7 +776,11 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
   @VisibleForTesting
   /* package */ void simulateCheckForKeyboardForTesting() {
-    getCustomGlobalLayoutListener().checkForKeyboardEvents();
+    if (Build.VERSION.SDK_INT >= 23) {
+      getCustomGlobalLayoutListener().checkForKeyboardEvents();
+    } else {
+      getCustomGlobalLayoutListener().checkForKeyboardEventsLegacy();
+    }
   }
 
   private CustomGlobalLayoutListener getCustomGlobalLayoutListener() {
@@ -879,7 +889,8 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     private final Rect mVisibleViewArea;
     private final int mMinKeyboardHeightDetected;
 
-    private int mKeyboardHeight = 0;
+    private boolean mKeyboardIsVisible = false;
+    private int mKeyboardHeight = 0; // Only used in checkForKeyboardEventsLegacy path
     private int mDeviceRotation = 0;
 
     /* package */ CustomGlobalLayoutListener() {
@@ -895,13 +906,62 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
           || mReactInstanceManager.getCurrentReactContext() == null) {
         return;
       }
-      checkForKeyboardEvents();
+
+      // WindowInsetsCompat IME measurement is reliable for API level 23+.
+      // https://developer.android.com/jetpack/androidx/releases/core#1.5.0-alpha02
+      if (Build.VERSION.SDK_INT >= 23) {
+        checkForKeyboardEvents();
+      } else {
+        checkForKeyboardEventsLegacy();
+      }
+
       checkForDeviceOrientationChanges();
       checkForDeviceDimensionsChanges();
     }
 
+    @RequiresApi(api = Build.VERSION_CODES.M)
     private void checkForKeyboardEvents() {
       getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
+      WindowInsets rootInsets = getRootView().getRootWindowInsets();
+      WindowInsetsCompat compatRootInsets = WindowInsetsCompat.toWindowInsetsCompat(rootInsets);
+
+      boolean keyboardIsVisible = compatRootInsets.isVisible(WindowInsetsCompat.Type.ime());
+      if (keyboardIsVisible != mKeyboardIsVisible) {
+        mKeyboardIsVisible = keyboardIsVisible;
+
+        if (keyboardIsVisible) {
+          Insets imeInsets = compatRootInsets.getInsets(WindowInsetsCompat.Type.ime());
+          Insets barInsets = compatRootInsets.getInsets(WindowInsetsCompat.Type.systemBars());
+          int height = imeInsets.bottom - barInsets.bottom;
+
+          int softInputMode = ((Activity) getContext()).getWindow().getAttributes().softInputMode;
+          int screenY =
+              softInputMode == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING
+                  ? mVisibleViewArea.bottom - height
+                  : mVisibleViewArea.bottom;
+
+          sendEvent(
+              "keyboardDidShow",
+              createKeyboardEventPayload(
+                  PixelUtil.toDIPFromPixel(screenY),
+                  PixelUtil.toDIPFromPixel(mVisibleViewArea.left),
+                  PixelUtil.toDIPFromPixel(mVisibleViewArea.width()),
+                  PixelUtil.toDIPFromPixel(height)));
+        } else {
+          sendEvent(
+              "keyboardDidHide",
+              createKeyboardEventPayload(
+                  PixelUtil.toDIPFromPixel(mLastHeight),
+                  0,
+                  PixelUtil.toDIPFromPixel(mVisibleViewArea.width()),
+                  0));
+        }
+      }
+    }
+
+    private void checkForKeyboardEventsLegacy() {
+      getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
+
       int notchHeight = 0;
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
         WindowInsets insets = getRootView().getRootWindowInsets();
@@ -919,8 +979,10 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
       boolean isKeyboardShowingOrKeyboardHeightChanged =
           mKeyboardHeight != heightDiff && heightDiff > mMinKeyboardHeightDetected;
+
       if (isKeyboardShowingOrKeyboardHeightChanged) {
         mKeyboardHeight = heightDiff;
+        mKeyboardIsVisible = true;
         sendEvent(
             "keyboardDidShow",
             createKeyboardEventPayload(
@@ -934,6 +996,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
       boolean isKeyboardHidden = mKeyboardHeight != 0 && heightDiff <= mMinKeyboardHeightDetected;
       if (isKeyboardHidden) {
         mKeyboardHeight = 0;
+        mKeyboardIsVisible = false;
         sendEvent(
             "keyboardDidHide",
             createKeyboardEventPayload(

package/ReactAndroid/src/main/java/com/facebook/react/TurboReactPackage.java

@@ -8,6 +8,7 @@
 package com.facebook.react;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import com.facebook.react.bridge.ModuleHolder;
 import com.facebook.react.bridge.ModuleSpec;
 import com.facebook.react.bridge.NativeModule;
@@ -42,7 +43,8 @@ public abstract class TurboReactPackage implements ReactPackage {
    * @param reactContext
    * @return
    */
-  public abstract NativeModule getModule(String name, final ReactApplicationContext reactContext);
+  public abstract @Nullable NativeModule getModule(
+      String name, final ReactApplicationContext reactContext);
 
   /**
    * This is a temporary method till we implement TurboModules. Once we implement TurboModules, we

package/ReactAndroid/src/main/java/com/facebook/react/animated/BUCK

@@ -6,10 +6,8 @@ rn_android_library(
         "*.java",
     ]),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "JAVA",
     provided_deps = [

package/ReactAndroid/src/main/java/com/facebook/react/animated/EventAnimationDriver.java

@@ -21,8 +21,13 @@ import java.util.List;
 /* package */ class EventAnimationDriver implements RCTEventEmitter {
   private List<String> mEventPath;
   /* package */ ValueAnimatedNode mValueNode;
+  /* package */ String mEventName;
+  /* package */ int mViewTag;
 
-  public EventAnimationDriver(List<String> eventPath, ValueAnimatedNode valueNode) {
+  public EventAnimationDriver(
+      String eventName, int viewTag, List<String> eventPath, ValueAnimatedNode valueNode) {
+    mEventName = eventName;
+    mViewTag = viewTag;
     mEventPath = eventPath;
     mValueNode = valueNode;
   }

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.java

@@ -25,7 +25,6 @@ import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UIManagerListener;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.annotations.VisibleForTesting;
-import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.modules.core.ReactChoreographer;
@@ -154,38 +153,21 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
   private class ConcurrentOperationQueue {
     private final Queue<UIThreadOperation> mQueue = new ConcurrentLinkedQueue<>();
     @Nullable private UIThreadOperation mPeekedOperation = null;
-    private boolean mSynchronizedAccess = false;
 
     @AnyThread
     boolean isEmpty() {
       return mQueue.isEmpty() && mPeekedOperation == null;
     }
 
-    void setSynchronizedAccess(boolean isSynchronizedAccess) {
-      mSynchronizedAccess = isSynchronizedAccess;
-    }
-
     @AnyThread
     void add(UIThreadOperation operation) {
-      if (mSynchronizedAccess) {
-        synchronized (this) {
-          mQueue.add(operation);
-        }
-      } else {
-        mQueue.add(operation);
-      }
+      mQueue.add(operation);
     }
 
     @UiThread
     void executeBatch(long maxBatchNumber, NativeAnimatedNodesManager nodesManager) {
       List<UIThreadOperation> operations;
-      if (mSynchronizedAccess) {
-        synchronized (this) {
-          operations = drainQueueIntoList(maxBatchNumber);
-        }
-      } else {
-        operations = drainQueueIntoList(maxBatchNumber);
-      }
+      operations = drainQueueIntoList(maxBatchNumber);
       if (operations != null) {
         for (UIThreadOperation operation : operations) {
           operation.execute(nodesManager);
@@ -280,10 +262,6 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
             }
           }
         };
-
-    // If shipping this flag, make sure to migrate to non-concurrent queue for efficiency
-    mOperations.setSynchronizedAccess(ReactFeatureFlags.enableSynchronizationForAnimated);
-    mPreOperations.setSynchronizedAccess(ReactFeatureFlags.enableSynchronizationForAnimated);
   }
 
   @Override

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java

@@ -31,11 +31,9 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
-import java.util.Map;
 import java.util.Queue;
 
 /**
@@ -58,9 +56,9 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
   private final SparseArray<AnimatedNode> mAnimatedNodes = new SparseArray<>();
   private final SparseArray<AnimationDriver> mActiveAnimations = new SparseArray<>();
   private final SparseArray<AnimatedNode> mUpdatedNodes = new SparseArray<>();
-  // Mapping of a view tag and an event name to a list of event animation drivers. 99% of the time
-  // there will be only one driver per mapping so all code code should be optimized around that.
-  private final Map<String, List<EventAnimationDriver>> mEventDrivers = new HashMap<>();
+  // List of event animation drivers for an event on view.
+  // There may be multiple drivers for the same event and view.
+  private final List<EventAnimationDriver> mEventDrivers = new ArrayList<>();
   private final ReactApplicationContext mReactApplicationContext;
   private int mAnimatedGraphBFSColor = 0;
   // Used to avoid allocating a new array on every frame in `runUpdates` and `onEventDispatch`.
@@ -501,7 +499,8 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
   }
 
   @UiThread
-  public void addAnimatedEventToView(int viewTag, String eventName, ReadableMap eventMapping) {
+  public void addAnimatedEventToView(
+      int viewTag, String eventHandlerName, ReadableMap eventMapping) {
     int nodeTag = eventMapping.getInt("animatedValueTag");
     AnimatedNode node = mAnimatedNodes.get(nodeTag);
     if (node == null) {
@@ -512,8 +511,8 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       throw new JSApplicationIllegalArgumentException(
           "addAnimatedEventToView: Animated node on view ["
               + viewTag
-              + "] connected to event ("
-              + eventName
+              + "] connected to event handler ("
+              + eventHandlerName
               + ") should be of type "
               + ValueAnimatedNode.class.getName());
     }
@@ -524,32 +523,27 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       pathList.add(path.getString(i));
     }
 
-    EventAnimationDriver event = new EventAnimationDriver(pathList, (ValueAnimatedNode) node);
-    String key = viewTag + eventName;
-    if (mEventDrivers.containsKey(key)) {
-      mEventDrivers.get(key).add(event);
-    } else {
-      List<EventAnimationDriver> drivers = new ArrayList<>(1);
-      drivers.add(event);
-      mEventDrivers.put(key, drivers);
-    }
+    String eventName = normalizeEventName(eventHandlerName);
+
+    EventAnimationDriver eventDriver =
+        new EventAnimationDriver(eventName, viewTag, pathList, (ValueAnimatedNode) node);
+    mEventDrivers.add(eventDriver);
   }
 
   @UiThread
-  public void removeAnimatedEventFromView(int viewTag, String eventName, int animatedValueTag) {
-    String key = viewTag + eventName;
-    if (mEventDrivers.containsKey(key)) {
-      List<EventAnimationDriver> driversForKey = mEventDrivers.get(key);
-      if (driversForKey.size() == 1) {
-        mEventDrivers.remove(viewTag + eventName);
-      } else {
-        ListIterator<EventAnimationDriver> it = driversForKey.listIterator();
-        while (it.hasNext()) {
-          if (it.next().mValueNode.mTag == animatedValueTag) {
-            it.remove();
-            break;
-          }
-        }
+  public void removeAnimatedEventFromView(
+      int viewTag, String eventHandlerName, int animatedValueTag) {
+
+    String eventName = normalizeEventName(eventHandlerName);
+
+    ListIterator<EventAnimationDriver> it = mEventDrivers.listIterator();
+    while (it.hasNext()) {
+      EventAnimationDriver driver = it.next();
+      if (eventName.equals(driver.mEventName)
+          && viewTag == driver.mViewTag
+          && animatedValueTag == driver.mValueNode.mTag) {
+        it.remove();
+        break;
       }
     }
   }
@@ -585,18 +579,19 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       if (uiManager == null) {
         return;
       }
-      String eventName = uiManager.resolveCustomDirectEventName(event.getEventName());
-      if (eventName == null) {
-        eventName = "";
-      }
 
-      List<EventAnimationDriver> driversForKey = mEventDrivers.get(event.getViewTag() + eventName);
-      if (driversForKey != null) {
-        for (EventAnimationDriver driver : driversForKey) {
+      boolean foundAtLeastOneDriver = false;
+      Event.EventAnimationDriverMatchSpec matchSpec = event.getEventAnimationDriverMatchSpec();
+      for (EventAnimationDriver driver : mEventDrivers) {
+        if (matchSpec.match(driver.mViewTag, driver.mEventName)) {
+          foundAtLeastOneDriver = true;
           stopAnimationsForNode(driver.mValueNode);
           event.dispatch(driver);
           mRunUpdateNodeList.add(driver.mValueNode);
         }
+      }
+
+      if (foundAtLeastOneDriver) {
         updateNodes(mRunUpdateNodeList);
         mRunUpdateNodeList.clear();
       }
@@ -824,4 +819,14 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       mWarnedAboutGraphTraversal = false;
     }
   }
+
+  private String normalizeEventName(String eventHandlerName) {
+    // Fabric UIManager also makes this assumption
+    String eventName = eventHandlerName;
+    if (eventHandlerName.startsWith("on")) {
+      eventName = "top" + eventHandlerName.substring(2);
+    }
+
+    return eventName;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BUCK

@@ -21,10 +21,8 @@ rn_android_library(
         exclude = INTERFACES,
     ),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "JAVA",
     proguard_config = "reactnative.pro",
@@ -71,10 +69,8 @@ rn_android_library(
     name = "interfaces",
     srcs = glob(INTERFACES),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "JAVA",
     proguard_config = "reactnative.pro",

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

@@ -108,8 +108,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
   // C++ parts
   private final HybridData mHybridData;
 
-  private static native HybridData initHybrid(
-      boolean enableRuntimeScheduler, boolean enableRuntimeSchedulerInTurboModule);
+  private static native HybridData initHybrid();
 
   public native CallInvokerHolderImpl getJSCallInvokerHolder();
 
@@ -124,15 +123,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
     FLog.d(ReactConstants.TAG, "Initializing React Xplat Bridge.");
     Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "createCatalystInstanceImpl");
 
-    if (ReactFeatureFlags.enableRuntimeSchedulerInTurboModule
-        && !ReactFeatureFlags.enableRuntimeScheduler) {
-      Assertions.assertUnreachable();
-    }
-
-    mHybridData =
-        initHybrid(
-            ReactFeatureFlags.enableRuntimeScheduler,
-            ReactFeatureFlags.enableRuntimeSchedulerInTurboModule);
+    mHybridData = initHybrid();
 
     mReactQueueConfiguration =
         ReactQueueConfigurationImpl.create(

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

@@ -32,7 +32,7 @@ public class ReactCxxErrorHandler {
         parameters[0] = new Exception(message);
         mHandleErrorFunc.invoke(mObject, parameters);
       } catch (Exception e) {
-        FLog.e("ReactCxxErrorHandler", "Failed to invole error hanlder function", e);
+        FLog.e("ReactCxxErrorHandler", "Failed to invoke error handler function", e);
       }
     }
   }

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

@@ -12,10 +12,8 @@ rn_android_library(
         exclude = SUB_PROJECTS,
     ),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "JAVA",
     provided_deps = [

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

@@ -7,10 +7,8 @@ rn_android_library(
         "*.kt",
     ]),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
     language = "KOTLIN",
     provided_deps = [],
@@ -22,7 +20,7 @@ rn_android_library(
     deps = [
         FBJNI_TARGET,
         react_native_dep("libraries/soloader/java/com/facebook/soloader:soloader"),
-        react_native_target("java/com/facebook/react/common/mapbuffer/jni:jni"),
+        react_native_target("jni/react/mapbuffer:jni"),
         react_native_dep("libraries/fbjni:java"),
         react_native_dep("third-party/android/androidx:annotation"),
         react_native_dep("third-party/java/infer-annotations:infer-annotations"),

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/MapBuffer.kt

@@ -126,6 +126,16 @@ interface MapBuffer : Iterable<MapBuffer.Entry> {
    */
   fun getMapBuffer(key: Int): MapBuffer
 
+  /**
+   * Provides parsed [List<MapBuffer>] value if the entry for given key exists with [DataType.MAP]
+   * type
+   * @param key key to lookup [List<MapBuffer>] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  fun getMapBufferList(key: Int): List<MapBuffer>
+
   /** Iterable entry representing parsed MapBuffer values */
   interface Entry {
     /**