Add scaffolding for batched animated prop updates delegate chain

Summary:
Introduces the cross-platform delegate chain for batched animated property updates without any platform implementation:

- Adds `schedulerShouldSynchronouslyUpdateAnimatedPropsOnUIThread` to `SchedulerDelegate` and forwards from `Scheduler`.
- Adds `uiManagerShouldSynchronouslyUpdateAnimatedPropsOnUIThread` to `UIManagerDelegate` and `synchronouslyUpdateAnimatedPropsOnUIThread` to `UIManager`.
- Adds no-op stubs in iOS (`RCTScheduler.mm`), macOS (`RCTScheduler.mm`), Windows (`FabricUIManagerModule`) and CxxPlatform (`SchedulerDelegateImpl`).

No behavioural impact; Android implementation lands in a follow-up.

Changelog:
[Internal]

Differential Revision: D104672455

Author: Bartlomiej Bloniarz

packages/react-native/React/Fabric/RCTScheduler.mm

@@ -79,6 +79,13 @@ void schedulerShouldSynchronouslyUpdateViewOnUIThread(facebook::react::Tag tag,
     [scheduler.delegate schedulerDidSynchronouslyUpdateViewOnUIThread:tag props:props];
   }
 
+  void schedulerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+      SurfaceId surfaceId,
+      const std::unordered_map<Tag, AnimatedProps> &updates) override
+  {
+    // Not implemented on iOS yet -- filled in by a later commit.
+  }
+
   void schedulerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override
   {
     // Does nothing.

packages/react-native/ReactAndroid/src/main/jni/react/fabric/FabricUIManagerBinding.cpp

@@ -20,6 +20,7 @@
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/animationbackend/AnimatedProps.h>
 #include <react/renderer/animations/LayoutAnimationDriver.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/EventBeat.h>
@@ -792,6 +793,13 @@ void FabricUIManagerBinding::schedulerShouldSynchronouslyUpdateViewOnUIThread(
   }
 }
 
+void FabricUIManagerBinding::
+    schedulerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+        SurfaceId /*surfaceId*/,
+        const std::unordered_map<Tag, AnimatedProps>& /*updates*/) {
+  // Implemented in a follow-up.
+}
+
 void FabricUIManagerBinding::schedulerDidUpdateShadowTree(
     const std::unordered_map<Tag, folly::dynamic>& /*tagToProps*/) {
   // no-op

packages/react-native/ReactAndroid/src/main/jni/react/fabric/FabricUIManagerBinding.h

@@ -115,6 +115,10 @@ class FabricUIManagerBinding : public jni::HybridClass<FabricUIManagerBinding>,
 
   void schedulerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) override;
 
+  void schedulerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+      SurfaceId surfaceId,
+      const std::unordered_map<Tag, AnimatedProps> &updates) override;
+
   void schedulerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
 
   void schedulerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) override;

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

@@ -401,6 +401,15 @@ void Scheduler::uiManagerShouldSynchronouslyUpdateViewOnUIThread(
   }
 }
 
+void Scheduler::uiManagerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+    SurfaceId surfaceId,
+    const std::unordered_map<Tag, AnimatedProps>& updates) {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+        surfaceId, updates);
+  }
+}
+
 void Scheduler::uiManagerDidUpdateShadowTree(
     const std::unordered_map<Tag, folly::dynamic>& tagToProps) {
   if (delegate_ != nullptr) {

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

@@ -94,6 +94,9 @@ class Scheduler final : public UIManagerDelegate {
       bool isJSResponder,
       bool blockNativeResponder) override;
   void uiManagerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) override;
+  void uiManagerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+      SurfaceId surfaceId,
+      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.h

@@ -8,13 +8,16 @@
 #pragma once
 
 #include <memory>
+#include <unordered_map>
 
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowView.h>
 
 namespace facebook::react {
 
+struct AnimatedProps;
+
 /*
  * Abstract class for Scheduler's delegate.
  */
@@ -64,6 +67,17 @@ class SchedulerDelegate {
 
   virtual void schedulerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) = 0;
 
+  /**
+   * Synchronously update animated properties for multiple views on the UI
+   * thread. Each entry maps a Tag to the AnimatedProps that should be applied
+   * to that view. Platform implementations translate AnimatedProps into the
+   * native update mechanism (e.g. buffer protocol on Android, typed props on
+   * iOS).
+   */
+  virtual void schedulerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+      SurfaceId surfaceId,
+      const std::unordered_map<Tag, AnimatedProps> &updates) = 0;
+
   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/uimanager/UIManager.cpp

@@ -765,6 +765,15 @@ void UIManager::synchronouslyUpdateViewOnUIThread(
   }
 }
 
+void UIManager::synchronouslyUpdateAnimatedPropsOnUIThread(
+    SurfaceId surfaceId,
+    const std::unordered_map<Tag, AnimatedProps>& updates) {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+        surfaceId, updates);
+  }
+}
+
 #pragma mark ContextContainer
 
 std::shared_ptr<const ContextContainer> UIManager::getContextContainer() const {

packages/react-native/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -85,6 +85,10 @@ class UIManager final : public ShadowTreeDelegate {
 
   void synchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props);
 
+  void synchronouslyUpdateAnimatedPropsOnUIThread(
+      SurfaceId surfaceId,
+      const std::unordered_map<Tag, AnimatedProps> &updates);
+
   /*
    * Provides access to a UIManagerBinding.
    * The `callback` methods will not be called if the internal pointer to

packages/react-native/ReactCommon/react/renderer/uimanager/UIManagerAnimationBackend.h

@@ -15,6 +15,7 @@
 
 namespace facebook::react {
 
+struct AnimatedProps;
 struct AnimationMutations;
 
 using AnimationTimestamp = std::chrono::duration<double, std::milli>;

packages/react-native/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -7,13 +7,17 @@
 
 #pragma once
 
+#include <unordered_map>
+
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowTree.h>
 
 namespace facebook::react {
 
+struct AnimatedProps;
+
 /*
  * Abstract class for UIManager's delegate.
  */
@@ -64,6 +68,13 @@ class UIManagerDelegate {
    */
   virtual void uiManagerShouldSynchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic &props) = 0;
 
+  /*
+   * Synchronously update animated properties on the UI thread.
+   */
+  virtual void uiManagerShouldSynchronouslyUpdateAnimatedPropsOnUIThread(
+      SurfaceId surfaceId,
+      const std::unordered_map<Tag, AnimatedProps> &updates) = 0;
+
   /*
    * Called after updateShadowTree is invoked.
    */