react-native-tvos 0.69.8-2 → 0.71.7-0rc0

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;
 
 /**
@@ -74,9 +73,9 @@ public abstract class ReactNativeHost {
             .setDevSupportManagerFactory(getDevSupportManagerFactory())
             .setRequireActivity(getShouldRequireActivity())
             .setSurfaceDelegateFactory(getSurfaceDelegateFactory())
+            .setLazyViewManagersEnabled(getLazyViewManagersEnabled())
             .setRedBoxHandler(getRedBoxHandler())
             .setJavaScriptExecutorFactory(getJavaScriptExecutorFactory())
-            .setUIImplementationProvider(getUIImplementationProvider())
             .setJSIModulesPackage(getJSIModulePackage())
             .setInitialLifecycleState(LifecycleState.BEFORE_CREATE)
             .setReactPackageTurboModuleManagerDelegateBuilder(
@@ -116,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;
   }
@@ -135,6 +124,16 @@ public abstract class ReactNativeHost {
     return true;
   }
 
+  /**
+   * Returns whether view managers should be created lazily. See {@link
+   * ViewManagerOnDemandReactPackage} for details.
+   *
+   * @experimental
+   */
+  public boolean getLazyViewManagersEnabled() {
+    return false;
+  }
+
   /**
    * Return the {@link SurfaceDelegateFactory} used by NativeModules to get access to a {@link
    * SurfaceDelegate} to interact with a surface. By default in the mobile platform the {@link
@@ -191,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,8 +12,10 @@ 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.Insets;
 import android.graphics.Point;
 import android.graphics.Rect;
 import android.os.Build;
@@ -31,6 +33,7 @@ import android.view.WindowInsets;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.ThreadConfined;
@@ -57,6 +60,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 +131,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   }
 
   private void init() {
+    setRootViewTag(ReactRootViewTagGenerator.getNextRootViewTag());
     setClipChildren(false);
   }
 
@@ -338,7 +343,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     super.requestChildFocus(child, focused);
   }
 
-  private void dispatchJSPointerEvent(MotionEvent event) {
+  protected void dispatchJSPointerEvent(MotionEvent event) {
     if (mReactInstanceManager == null
         || !mIsAttachedToInstance
         || mReactInstanceManager.getCurrentReactContext() == null) {
@@ -361,7 +366,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     }
   }
 
-  private void dispatchJSTouchEvent(MotionEvent event) {
+  protected void dispatchJSTouchEvent(MotionEvent event) {
     if (mReactInstanceManager == null
         || !mIsAttachedToInstance
         || mReactInstanceManager.getCurrentReactContext() == null) {
@@ -770,7 +775,11 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
   @VisibleForTesting
   /* package */ void simulateCheckForKeyboardForTesting() {
-    getCustomGlobalLayoutListener().checkForKeyboardEvents();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      getCustomGlobalLayoutListener().checkForKeyboardEvents();
+    } else {
+      getCustomGlobalLayoutListener().checkForKeyboardEventsLegacy();
+    }
   }
 
   private CustomGlobalLayoutListener getCustomGlobalLayoutListener() {
@@ -880,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() {
@@ -896,13 +906,62 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
           || mReactInstanceManager.getCurrentReactContext() == null) {
         return;
       }
-      checkForKeyboardEvents();
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        checkForKeyboardEvents();
+      } else {
+        checkForKeyboardEventsLegacy();
+      }
+
       checkForDeviceOrientationChanges();
       checkForDeviceDimensionsChanges();
     }
 
+    @RequiresApi(api = Build.VERSION_CODES.R)
     private void checkForKeyboardEvents() {
       getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
+      WindowInsets rootInsets = getRootView().getRootWindowInsets();
+      if (rootInsets == null) {
+        return;
+      }
+
+      boolean keyboardIsVisible = rootInsets.isVisible(WindowInsets.Type.ime());
+      if (keyboardIsVisible != mKeyboardIsVisible) {
+        mKeyboardIsVisible = keyboardIsVisible;
+
+        if (keyboardIsVisible) {
+          Insets imeInsets = rootInsets.getInsets(WindowInsets.Type.ime());
+          Insets barInsets = rootInsets.getInsets(WindowInsets.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();
@@ -920,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(
@@ -935,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/ViewManagerOnDemandReactPackage.java

@@ -10,15 +10,14 @@ package com.facebook.react;
 import androidx.annotation.Nullable;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
-import java.util.List;
+import java.util.Collection;
 
 public interface ViewManagerOnDemandReactPackage {
   /**
    * Provides a list of names of ViewManagers with which these modules can be accessed from JS.
    * Typically, this is ViewManager.getName().
    */
-  @Nullable
-  List<String> getViewManagerNames(ReactApplicationContext reactContext);
+  Collection<String> getViewManagerNames(ReactApplicationContext reactContext);
   /**
    * Creates and returns a ViewManager with a specific name {@param viewManagerName}. It's up to an
    * implementing package how to interpret the name.

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

@@ -6,11 +6,10 @@ rn_android_library(
         "*.java",
     ]),
     autoglob = False,
-    is_androidx = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
-        "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     provided_deps = [
         react_native_dep("third-party/android/androidx:annotation"),
         react_native_dep("third-party/android/androidx:core"),

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

@@ -19,12 +19,12 @@ import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 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;
@@ -92,6 +92,50 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
   public static final String NAME = "NativeAnimatedModule";
   public static final boolean ANIMATED_MODULE_DEBUG = false;
 
+  // For `queueAndExecuteBatchedOperations`
+  private enum BatchExecutionOpCodes {
+    OP_CODE_CREATE_ANIMATED_NODE(1),
+    OP_CODE_UPDATE_ANIMATED_NODE_CONFIG(2),
+    OP_CODE_GET_VALUE(3),
+    OP_START_LISTENING_TO_ANIMATED_NODE_VALUE(4),
+    OP_STOP_LISTENING_TO_ANIMATED_NODE_VALUE(5),
+    OP_CODE_CONNECT_ANIMATED_NODES(6),
+    OP_CODE_DISCONNECT_ANIMATED_NODES(7),
+    OP_CODE_START_ANIMATING_NODE(8),
+    OP_CODE_STOP_ANIMATION(9),
+    OP_CODE_SET_ANIMATED_NODE_VALUE(10),
+    OP_CODE_SET_ANIMATED_NODE_OFFSET(11),
+    OP_CODE_FLATTEN_ANIMATED_NODE_OFFSET(12),
+    OP_CODE_EXTRACT_ANIMATED_NODE_OFFSET(13),
+    OP_CODE_CONNECT_ANIMATED_NODE_TO_VIEW(14),
+    OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW(15),
+    OP_CODE_RESTORE_DEFAULT_VALUES(16),
+    OP_CODE_DROP_ANIMATED_NODE(17),
+    OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW(18),
+    OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW(19),
+    OP_CODE_ADD_LISTENER(20), // ios only
+    OP_CODE_REMOVE_LISTENERS(21); // ios only
+
+    private static BatchExecutionOpCodes[] valueMap = null;
+    private final int value;
+
+    private BatchExecutionOpCodes(int value) {
+      this.value = value;
+    }
+
+    public int getValue() {
+      return this.value;
+    }
+
+    public static BatchExecutionOpCodes fromId(int id) {
+      if (BatchExecutionOpCodes.valueMap == null) {
+        BatchExecutionOpCodes.valueMap = BatchExecutionOpCodes.values();
+      }
+      // Enum values are 1-indexed, but the value array is 0-indexed
+      return BatchExecutionOpCodes.valueMap[id - 1];
+    }
+  }
+
   private abstract class UIThreadOperation {
     abstract void execute(NativeAnimatedNodesManager animatedNodesManager);
 
@@ -109,47 +153,34 @@ 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;
+      return mQueue.isEmpty() && mPeekedOperation == null;
     }
 
     @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);
+      operations = drainQueueIntoList(maxBatchNumber);
+      if (operations != null) {
+        for (UIThreadOperation operation : operations) {
+          operation.execute(nodesManager);
         }
-      } else {
-        operations = drainQueueIntoList(maxBatchNumber);
-      }
-      for (UIThreadOperation operation : operations) {
-        operation.execute(nodesManager);
       }
     }
 
     @UiThread
-    private List<UIThreadOperation> drainQueueIntoList(long maxBatchNumber) {
+    private @Nullable List<UIThreadOperation> drainQueueIntoList(long maxBatchNumber) {
+      if (isEmpty()) {
+        return null;
+      }
+
       List<UIThreadOperation> operations = new ArrayList<>();
       while (true) {
         // Due to a race condition, we manually "carry-over" a polled item from previous batch
@@ -231,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
@@ -362,7 +389,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
    * @return {@link NativeAnimatedNodesManager}
    */
   @Nullable
-  private NativeAnimatedNodesManager getNodesManager() {
+  public NativeAnimatedNodesManager getNodesManager() {
     if (mNodesManager.get() == null) {
       ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
 
@@ -822,7 +849,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     if (ANIMATED_MODULE_DEBUG) {
       FLog.d(
           NAME,
-          "queue: disconnectAnimatedNodeFromView: " + animatedNodeTag + " viewTag: " + viewTag);
+          "queue disconnectAnimatedNodeFromView: " + animatedNodeTag + " viewTag: " + viewTag);
     }
 
     decrementInFlightAnimationsForViewTag(viewTag);
@@ -834,7 +861,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
             if (ANIMATED_MODULE_DEBUG) {
               FLog.d(
                   NAME,
-                  "execute: disconnectAnimatedNodeFromView: "
+                  "execute disconnectAnimatedNodeFromView: "
                       + animatedNodeTag
                       + " viewTag: "
                       + viewTag);
@@ -848,8 +875,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
   public void restoreDefaultValues(final double animatedNodeTagDouble) {
     final int animatedNodeTag = (int) animatedNodeTagDouble;
     if (ANIMATED_MODULE_DEBUG) {
-      FLog.d(
-          NAME, "queue restoreDefaultValues: disconnectAnimatedNodeFromView: " + animatedNodeTag);
+      FLog.d(NAME, "queue restoreDefaultValues: " + animatedNodeTag);
     }
 
     addPreOperation(
@@ -857,10 +883,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
           @Override
           public void execute(NativeAnimatedNodesManager animatedNodesManager) {
             if (ANIMATED_MODULE_DEBUG) {
-              FLog.d(
-                  NAME,
-                  "execute restoreDefaultValues: disconnectAnimatedNodeFromView: "
-                      + animatedNodeTag);
+              FLog.d(NAME, "execute restoreDefaultValues: " + animatedNodeTag);
             }
             animatedNodesManager.restoreDefaultValues(animatedNodeTag);
           }
@@ -969,4 +992,191 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
       context.removeLifecycleEventListener(this);
     }
   }
+
+  /**
+   * This is a currently-experimental method that allows JS to queue and immediately execute many
+   * instructions at once. Since we make 1 JNI/JSI call instead of N, this should significantly
+   * improve performance.
+   *
+   * <p>The arguments operate as a byte buffer. All integer command IDs and any args are packed into
+   * opsAndArgs.
+   *
+   * <p>For the getValue callback: since this is batched, we accumulate a list of all requested
+   * values, in order, and call the callback once at the end (if present) with the list of requested
+   * values.
+   */
+  @Override
+  public void queueAndExecuteBatchedOperations(final ReadableArray opsAndArgs) {
+    final int opBufferSize = opsAndArgs.size();
+
+    if (ANIMATED_MODULE_DEBUG) {
+      FLog.e(NAME, "queueAndExecuteBatchedOperations: opBufferSize: " + opBufferSize);
+    }
+
+    // This block of code is unfortunate and should be refactored - we just want to
+    // extract the ViewTags in the ReadableArray to mark animations on views as being enabled.
+    // We only do this for initializing animations on views - disabling animations on views
+    // happens later, when the disconnect/stop operations are actually executed.
+    for (int i = 0; i < opBufferSize; ) {
+      BatchExecutionOpCodes command = BatchExecutionOpCodes.fromId(opsAndArgs.getInt(i++));
+      switch (command) {
+        case OP_CODE_GET_VALUE:
+        case OP_START_LISTENING_TO_ANIMATED_NODE_VALUE:
+        case OP_STOP_LISTENING_TO_ANIMATED_NODE_VALUE:
+        case OP_CODE_STOP_ANIMATION:
+        case OP_CODE_FLATTEN_ANIMATED_NODE_OFFSET:
+        case OP_CODE_EXTRACT_ANIMATED_NODE_OFFSET:
+        case OP_CODE_RESTORE_DEFAULT_VALUES:
+        case OP_CODE_DROP_ANIMATED_NODE:
+        case OP_CODE_ADD_LISTENER:
+        case OP_CODE_REMOVE_LISTENERS:
+          i++;
+          break;
+        case OP_CODE_CREATE_ANIMATED_NODE:
+        case OP_CODE_UPDATE_ANIMATED_NODE_CONFIG:
+        case OP_CODE_CONNECT_ANIMATED_NODES:
+        case OP_CODE_DISCONNECT_ANIMATED_NODES:
+        case OP_CODE_SET_ANIMATED_NODE_VALUE:
+        case OP_CODE_SET_ANIMATED_NODE_OFFSET:
+        case OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW:
+          i += 2;
+          break;
+        case OP_CODE_START_ANIMATING_NODE:
+        case OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW:
+          i += 3;
+          break;
+        case OP_CODE_CONNECT_ANIMATED_NODE_TO_VIEW:
+          i++; // tag
+          initializeLifecycleEventListenersForViewTag(opsAndArgs.getInt(i++)); // viewTag
+          break;
+        case OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW:
+          initializeLifecycleEventListenersForViewTag(opsAndArgs.getInt(i++)); // viewTag
+          i++; // eventName
+          i++; // eventMapping
+          break;
+        default:
+          throw new IllegalArgumentException(
+              "Batch animation execution op: fetching viewTag: unknown op code");
+      }
+    }
+
+    // Batching happens inside this operation - so signal to the thread loop that
+    // this operation should be executed as soon as possible, "unbatched" with other
+    // UIThreadOperations
+    startOperationBatch();
+    addUnbatchedOperation(
+        new UIThreadOperation() {
+          @Override
+          public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+            ReactApplicationContext reactApplicationContext =
+                getReactApplicationContextIfActiveOrWarn();
+
+            int viewTag = -1;
+            for (int i = 0; i < opBufferSize; ) {
+              BatchExecutionOpCodes command = BatchExecutionOpCodes.fromId(opsAndArgs.getInt(i++));
+
+              switch (command) {
+                case OP_CODE_CREATE_ANIMATED_NODE:
+                  animatedNodesManager.createAnimatedNode(
+                      opsAndArgs.getInt(i++), opsAndArgs.getMap(i++));
+                  break;
+                case OP_CODE_UPDATE_ANIMATED_NODE_CONFIG:
+                  animatedNodesManager.updateAnimatedNodeConfig(
+                      opsAndArgs.getInt(i++), opsAndArgs.getMap(i++));
+                  break;
+                case OP_CODE_GET_VALUE:
+                  animatedNodesManager.getValue(opsAndArgs.getInt(i++), null);
+                  break;
+                case OP_START_LISTENING_TO_ANIMATED_NODE_VALUE:
+                  final int tag = opsAndArgs.getInt(i++);
+                  final AnimatedNodeValueListener listener =
+                      new AnimatedNodeValueListener() {
+                        public void onValueUpdate(double value) {
+                          WritableMap onAnimatedValueData = Arguments.createMap();
+                          onAnimatedValueData.putInt("tag", tag);
+                          onAnimatedValueData.putDouble("value", value);
+
+                          ReactApplicationContext reactApplicationContext =
+                              getReactApplicationContextIfActiveOrWarn();
+                          if (reactApplicationContext != null) {
+                            reactApplicationContext
+                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                                .emit("onAnimatedValueUpdate", onAnimatedValueData);
+                          }
+                        }
+                      };
+                  animatedNodesManager.startListeningToAnimatedNodeValue(tag, listener);
+                  break;
+                case OP_STOP_LISTENING_TO_ANIMATED_NODE_VALUE:
+                  animatedNodesManager.stopListeningToAnimatedNodeValue(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_CONNECT_ANIMATED_NODES:
+                  animatedNodesManager.connectAnimatedNodes(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_DISCONNECT_ANIMATED_NODES:
+                  animatedNodesManager.disconnectAnimatedNodes(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_START_ANIMATING_NODE:
+                  animatedNodesManager.startAnimatingNode(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++), opsAndArgs.getMap(i++), null);
+                  break;
+                case OP_CODE_STOP_ANIMATION:
+                  animatedNodesManager.stopAnimation(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_SET_ANIMATED_NODE_VALUE:
+                  animatedNodesManager.setAnimatedNodeValue(
+                      opsAndArgs.getInt(i++), opsAndArgs.getDouble(i++));
+                  break;
+                case OP_CODE_SET_ANIMATED_NODE_OFFSET:
+                  animatedNodesManager.setAnimatedNodeValue(
+                      opsAndArgs.getInt(i++), opsAndArgs.getDouble(i++));
+                  break;
+                case OP_CODE_FLATTEN_ANIMATED_NODE_OFFSET:
+                  animatedNodesManager.flattenAnimatedNodeOffset(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_EXTRACT_ANIMATED_NODE_OFFSET:
+                  animatedNodesManager.extractAnimatedNodeOffset(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_CONNECT_ANIMATED_NODE_TO_VIEW:
+                  animatedNodesManager.connectAnimatedNodeToView(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW:
+                  int animatedNodeTag = opsAndArgs.getInt(i++);
+                  viewTag = opsAndArgs.getInt(i++);
+                  decrementInFlightAnimationsForViewTag(viewTag);
+                  animatedNodesManager.disconnectAnimatedNodeFromView(animatedNodeTag, viewTag);
+                  break;
+                case OP_CODE_RESTORE_DEFAULT_VALUES:
+                  animatedNodesManager.restoreDefaultValues(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_DROP_ANIMATED_NODE:
+                  animatedNodesManager.dropAnimatedNode(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW:
+                  animatedNodesManager.addAnimatedEventToView(
+                      opsAndArgs.getInt(i++), opsAndArgs.getString(i++), opsAndArgs.getMap(i++));
+                  break;
+                case OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW:
+                  viewTag = opsAndArgs.getInt(i++);
+                  decrementInFlightAnimationsForViewTag(viewTag);
+                  animatedNodesManager.removeAnimatedEventFromView(
+                      viewTag, opsAndArgs.getString(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_ADD_LISTENER:
+                case OP_CODE_REMOVE_LISTENERS:
+                  i++;
+                  // ios only, do nothing on android besides incrementing the arg counter
+                  break;
+                default:
+                  throw new IllegalArgumentException(
+                      "Batch animation execution op: unknown op code");
+              }
+            }
+          }
+        });
+    finishOperationBatch();
+  }
 }