Add a batched scheduler delegate call for animated prop updates (#58773)

Summary:
Pull Request resolved: #58773

The animation backend hands its synchronous updates to the platform one view at a time. This adds `UIManager::synchronouslyUpdateAnimatedProps` and a matching `SchedulerDelegate` call that receive a whole frame's updates at once, continuing #56771. The backend uses it when `optimizedAnimatedPropUpdates` is on, and that flag's description now only promises what is implemented. The default `SchedulerDelegate` implementation forwards to the existing per-view update, so platforms that don't override it are unaffected. `UIManagerDelegate` gains a required method, implemented by `Scheduler`.

## Changelog:

[Internal]

Differential Revision: D122570617

Author: Bartlomiej Bloniarz

packages/react-native/Libraries/Animated/__tests__/AnimatedBackend-itest.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @fantom_flags useSharedAnimatedBackend:true updateRuntimeShadowNodeReferencesOnCommitThread:*
+ * @fantom_flags useSharedAnimatedBackend:true updateRuntimeShadowNodeReferencesOnCommitThread:* optimizedAnimatedPropUpdates:*
  * @flow strict-local
  * @format
  */

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlags.kt

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<86390dbd6b2c57cb4f8cdd7cb73cc1f7>>
+ * @generated SignedSource<<81b1343c027b377be3bdea9167e16a5d>>
  */
 
 /**
@@ -415,7 +415,7 @@ public object ReactNativeFeatureFlags {
   public fun fuseboxWebSocketEventsEnabled(): Boolean = accessor.fuseboxWebSocketEventsEnabled()
 
   /**
-   * When enabled, uses optimized platform-specific paths to apply animated props synchronously. On Android, this uses a batched int/double buffer protocol with a single JNI call. On iOS, this passes AnimatedProps directly through the delegate chain and applies them via cloneProps, avoiding the folly::dynamic round-trip.
+   * When enabled, uses optimized platform-specific paths to apply animated props synchronously. On Android, this uses a batched int/double buffer protocol with a single JNI call. Other platforms apply the props of each view through the existing synchronous update.
    */
   @JvmStatic
   public fun optimizedAnimatedPropUpdates(): Boolean = accessor.optimizedAnimatedPropUpdates()

packages/react-native/ReactCommon/react/featureflags/ReactNativeFeatureFlags.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<aef7d6ac25fdeb2423ebf4a2a9ac6f2e>>
+ * @generated SignedSource<<dae6ad344267433b319e0928830e0e11>>
  */
 
 /**
@@ -362,7 +362,7 @@ class ReactNativeFeatureFlags {
   RN_EXPORT static bool fuseboxWebSocketEventsEnabled();
 
   /**
-   * When enabled, uses optimized platform-specific paths to apply animated props synchronously. On Android, this uses a batched int/double buffer protocol with a single JNI call. On iOS, this passes AnimatedProps directly through the delegate chain and applies them via cloneProps, avoiding the folly::dynamic round-trip.
+   * When enabled, uses optimized platform-specific paths to apply animated props synchronously. On Android, this uses a batched int/double buffer protocol with a single JNI call. Other platforms apply the props of each view through the existing synchronous update.
    */
   RN_EXPORT static bool optimizedAnimatedPropUpdates();
 

packages/react-native/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -261,6 +261,12 @@ void AnimationBackend::commitUpdates(
 
 void AnimationBackend::synchronouslyUpdateProps(
     const std::unordered_map<Tag, AnimatedProps>& updates) {
+  if (ReactNativeFeatureFlags::optimizedAnimatedPropUpdates()) {
+    if (auto uiManager = uiManager_.lock()) {
+      uiManager->synchronouslyUpdateAnimatedProps(updates);
+    }
+    return;
+  }
   for (auto& [tag, animatedProps] : updates) {
     // TODO: We shouldn't repack it into dynamic, but for that a rewrite
     // of synchronouslyUpdateViewOnUIThread is needed

packages/react-native/ReactCommon/react/renderer/animationbackend/tests/AnimationBackendTest.cpp

@@ -36,6 +36,8 @@ class RecordingUIManagerDelegate : public UIManagerDelegate {
     synchronousUpdates.emplace(tag, props);
   }
 
+  void uiManagerShouldSynchronouslyUpdateAnimatedProps(
+      const std::unordered_map<Tag, AnimatedProps>& /*updates*/) override {}
   void uiManagerDidFinishTransaction(
       std::shared_ptr<const MountingCoordinator> /*mountingCoordinator*/,
       bool /*mountSynchronously*/) override {}

packages/react-native/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -378,6 +378,13 @@ void Scheduler::uiManagerShouldSynchronouslyUpdateViewOnUIThread(
   }
 }
 
+void Scheduler::uiManagerShouldSynchronouslyUpdateAnimatedProps(
+    const std::unordered_map<Tag, AnimatedProps>& updates) {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerShouldSynchronouslyUpdateAnimatedProps(updates);
+  }
+}
+
 void Scheduler::uiManagerDidUpdateShadowTree(
     const std::unordered_map<Tag, folly::dynamic>& tagToProps) {
   if (delegate_ != nullptr) {

packages/react-native/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -97,6 +97,7 @@ class Scheduler final : public UIManagerDelegate {
       bool isJSResponder,
       bool blockNativeResponder) override;
   void uiManagerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) override;
+  void uiManagerShouldSynchronouslyUpdateAnimatedProps(const std::unordered_map<Tag, AnimatedProps> &updates) override;
   void uiManagerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
   void uiManagerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) override;
   void uiManagerDidSetViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId) override;

packages/react-native/ReactCommon/react/renderer/scheduler/SchedulerDelegate.cpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "SchedulerDelegate.h"
+
+#include <react/renderer/animationbackend/AnimatedProps.h>
+#include <react/renderer/animationbackend/AnimatedPropsSerializer.h>
+
+namespace facebook::react {
+
+void SchedulerDelegate::schedulerShouldSynchronouslyUpdateAnimatedProps(
+    const std::unordered_map<Tag, AnimatedProps>& updates) {
+  for (const auto& [tag, props] : updates) {
+    schedulerShouldSynchronouslyUpdateViewOnUIThread(
+        tag, animationbackend::packAnimatedProps(props));
+  }
+}
+
+} // namespace facebook::react

packages/react-native/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -10,13 +10,16 @@
 #include <react/cxxstableapi/FrameworksGuard.h>
 
 #include <memory>
+#include <unordered_map>
 
 #include <React/RendererCore.h>
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowView.h>
 
 namespace facebook::react {
 
+struct AnimatedProps;
+
 /*
  * Abstract class for Scheduler's delegate.
  */
@@ -66,6 +69,12 @@ class SchedulerDelegate {
 
   virtual void schedulerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) = 0;
 
+  /*
+   * Synchronous update of animated props for many views at once. By default,
+   * forwards each view to `schedulerShouldSynchronouslyUpdateViewOnUIThread`.
+   */
+  virtual void schedulerShouldSynchronouslyUpdateAnimatedProps(const std::unordered_map<Tag, AnimatedProps> &updates);
+
   virtual void schedulerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) = 0;
 
   // View transition bitmap snapshot capture and application.

packages/react-native/ReactCommon/react/renderer/scheduler/tests/SchedulerDelegateInvalidationTest.cpp

@@ -34,6 +34,7 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#include <react/renderer/animationbackend/AnimatedPropsBuilder.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/root/RootProps.h>
@@ -588,4 +589,37 @@ TEST_F(
   EXPECT_EQ(delegate_->shouldRenderTransactionsCount(), 1);
 }
 
+TEST(SchedulerDelegateTest, animatedPropsUseExistingViewUpdatesByDefault) {
+  class PropsDelegate : public RecordingDelegate {
+   public:
+    std::unordered_map<Tag, folly::dynamic> received;
+
+    void schedulerShouldSynchronouslyUpdateViewOnUIThread(
+        Tag tag,
+        const folly::dynamic& props) override {
+      received.emplace(tag, props);
+    }
+  } delegate;
+
+  std::unordered_map<Tag, AnimatedProps> updates;
+  updates.emplace(
+      10,
+      AnimatedProps{
+          .props = {},
+          .rawProps = std::make_unique<RawProps>(
+              folly::dynamic::object("opacity", 0.25))});
+  AnimatedPropsBuilder builder;
+  builder.setOpacity(0.75);
+  updates.emplace(20, builder.get());
+
+  delegate.schedulerShouldSynchronouslyUpdateAnimatedProps(updates);
+
+  ASSERT_EQ(delegate.received.size(), 2);
+  folly::dynamic expectedRaw = folly::dynamic::object("opacity", 0.25);
+  folly::dynamic expectedTyped = folly::dynamic::object("opacity", 0.75);
+  EXPECT_EQ(delegate.received.at(10), expectedRaw);
+  EXPECT_EQ(delegate.received.at(20), expectedTyped);
+  EXPECT_EQ(updates.at(10).rawProps->toDynamic(), delegate.received.at(10));
+}
+
 } // namespace facebook::react