react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.h

@@ -17,9 +17,8 @@
 #include <react/debug/flags.h>
 #include <react/renderer/animated/EventEmitterListener.h>
 #include <react/renderer/animated/event_drivers/EventAnimationDriver.h>
-#ifdef RN_USE_ANIMATION_BACKEND
+#include <react/renderer/animationbackend/AnimatedPropsBuilder.h>
 #include <react/renderer/animationbackend/AnimationBackend.h>
-#endif
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
@@ -102,7 +101,7 @@ class NativeAnimatedNodesManager {
 
   void connectAnimatedNodeToView(Tag propsNodeTag, Tag viewTag) noexcept;
 
-  void connectAnimatedNodeToShadowNodeFamily(Tag propsNodeTag, std::shared_ptr<const ShadowNodeFamily> family) noexcept;
+  void connectAnimatedNodeToShadowNodeFamily(Tag propsNodeTag, std::shared_ptr<ShadowNodeFamily> family) noexcept;
 
   void disconnectAnimatedNodes(Tag parentTag, Tag childTag) noexcept;
 
@@ -120,9 +119,13 @@ class NativeAnimatedNodesManager {
 
   void setAnimatedNodeOffset(Tag tag, double offset);
 
-#ifdef RN_USE_ANIMATION_BACKEND
-  AnimationMutations pullAnimationMutations();
-#endif
+  void insertMutations(
+      std::unordered_map<Tag, std::pair<ShadowNodeFamily::Weak, folly::dynamic>> &updates,
+      AnimationMutations &mutations,
+      AnimatedPropsBuilder &propsBuilder,
+      bool hasLayoutUpdates = false);
+  AnimationMutations onAnimationFrameForBackend(AnimatedPropsBuilder &propsBuilder, AnimationTimestamp timestamp);
+  AnimationMutations pullAnimationMutations(AnimationTimestamp timestamp);
 
 #pragma mark - Drivers
 
@@ -153,7 +156,8 @@ class NativeAnimatedNodesManager {
       Tag viewTag,
       const folly::dynamic &props,
       bool layoutStyleUpdated,
-      bool forceFabricCommit) noexcept;
+      bool forceFabricCommit,
+      ShadowNodeFamily::Weak shadowNodeFamily = {}) noexcept;
 
   /**
    * Commits all pending animated property updates to their respective views.
@@ -260,10 +264,9 @@ class NativeAnimatedNodesManager {
 
   std::unordered_map<Tag, folly::dynamic> updateViewProps_{};
   std::unordered_map<Tag, folly::dynamic> updateViewPropsDirect_{};
-
-  mutable std::mutex tagToShadowNodeFamilyMutex_;
-  std::unordered_map<Tag, std::weak_ptr<const ShadowNodeFamily>> tagToShadowNodeFamily_{};
-
+  std::unordered_map<Tag, std::pair<ShadowNodeFamily::Weak, folly::dynamic>> updateViewPropsForBackend_{};
+  std::unordered_map<Tag, std::pair<ShadowNodeFamily::Weak, folly::dynamic>> updateViewPropsDirectForBackend_{};
+  std::unordered_set<Tag> shouldRequestAsyncFlush_{};
   /*
    * Sometimes a view is not longer connected to a PropsAnimatedNode, but
    * NativeAnimated has previously changed the view's props via direct
@@ -279,6 +282,8 @@ class NativeAnimatedNodesManager {
   bool warnedAboutGraphTraversal_ = false;
 #endif
 
+  CallbackId animationBackendCallbackId_{0};
+
   friend class ColorAnimatedNode;
   friend class AnimationDriver;
   friend class AnimationTestsBase;

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManagerProvider.cpp

@@ -11,10 +11,8 @@
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/animated/MergedValueDispatcher.h>
 #include <react/renderer/animated/internal/AnimatedMountingOverrideDelegate.h>
-#ifdef RN_USE_ANIMATION_BACKEND
-#include <react/renderer/animationbackend/AnimationBackend.h>
-#endif
 #include <react/renderer/animated/internal/primitives.h>
+#include <react/renderer/animationbackend/AnimationBackend.h>
 #include <react/renderer/components/view/conversions.h>
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
@@ -47,8 +45,16 @@ std::shared_ptr<NativeAnimatedNodesManager>
 NativeAnimatedNodesManagerProvider::getOrCreate(
     jsi::Runtime& runtime,
     std::shared_ptr<CallInvoker> jsInvoker) {
-  if (nativeAnimatedNodesManager_ == nullptr) {
-    auto* uiManager = &UIManagerBinding::getBinding(runtime)->getUIManager();
+  if (nativeAnimatedNodesManager_ != nullptr) {
+    return nativeAnimatedNodesManager_;
+  }
+
+  auto* uiManager = &UIManagerBinding::getBinding(runtime)->getUIManager();
+
+  if (!ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    // === PATH 1: Legacy Backend (useSharedAnimatedBackend = false) ===
+    // Uses the architecture with MergedValueDispatcher and
+    // AnimatedMountingOverrideDelegate
 
     mergedValueDispatcher_ = std::make_unique<MergedValueDispatcher>(
         [jsInvoker](std::function<void()>&& func) {
@@ -86,90 +92,78 @@ NativeAnimatedNodesManagerProvider::getOrCreate(
       }
     };
 
-    if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
-#ifdef RN_USE_ANIMATION_BACKEND
-      // TODO: this should be initialized outside of animated, but for now it
-      // was convenient to do it here
-      animationBackend_ = std::make_shared<AnimationBackend>(
-          std::move(startOnRenderCallback_),
-          std::move(stopOnRenderCallback_),
-          std::move(directManipulationCallback),
-          std::move(fabricCommitCallback),
-          uiManager);
-
-      nativeAnimatedNodesManager_ =
-          std::make_shared<NativeAnimatedNodesManager>(animationBackend_);
-
-      nativeAnimatedDelegate_ =
-          std::make_shared<UIManagerNativeAnimatedDelegateBackendImpl>(
-              animationBackend_);
-
-      uiManager->unstable_setAnimationBackend(animationBackend_);
-#endif
-    } else {
-      nativeAnimatedNodesManager_ =
-          std::make_shared<NativeAnimatedNodesManager>(
-              std::move(directManipulationCallback),
-              std::move(fabricCommitCallback),
-              std::move(resolvePlatformColor),
-              std::move(startOnRenderCallback_),
-              std::move(stopOnRenderCallback_),
-              std::move(frameRateListenerCallback_));
-
-      nativeAnimatedDelegate_ =
-          std::make_shared<UIManagerNativeAnimatedDelegateImpl>(
-              nativeAnimatedNodesManager_);
-    }
-
-    addEventEmitterListener(
-        nativeAnimatedNodesManager_->getEventEmitterListener());
-
-    uiManager->addEventListener(
-        std::make_shared<EventListener>(
-            [eventEmitterListenerContainerWeak =
-                 std::weak_ptr<EventEmitterListenerContainer>(
-                     eventEmitterListenerContainer_)](
-                const RawEvent& rawEvent) {
-              const auto& eventTarget = rawEvent.eventTarget;
-              const auto& eventPayload = rawEvent.eventPayload;
-              if (eventTarget && eventPayload) {
-                if (auto eventEmitterListenerContainer =
-                        eventEmitterListenerContainerWeak.lock();
-                    eventEmitterListenerContainer != nullptr) {
-                  return eventEmitterListenerContainer->willDispatchEvent(
-                      eventTarget->getTag(), rawEvent.type, *eventPayload);
-                }
-              }
-              return false;
-            }));
+    nativeAnimatedNodesManager_ = std::make_shared<NativeAnimatedNodesManager>(
+        std::move(directManipulationCallback),
+        std::move(fabricCommitCallback),
+        std::move(resolvePlatformColor),
+        std::move(startOnRenderCallback_),
+        std::move(stopOnRenderCallback_),
+        std::move(frameRateListenerCallback_));
+
+    nativeAnimatedDelegate_ =
+        std::make_shared<UIManagerNativeAnimatedDelegateImpl>(
+            nativeAnimatedNodesManager_);
+
+    animatedMountingOverrideDelegate_ =
+        std::make_shared<AnimatedMountingOverrideDelegate>(
+            *nativeAnimatedNodesManager_, *scheduler);
+
+    // Register on existing surfaces
+    uiManager->getShadowTreeRegistry().enumerate(
+        [animatedMountingOverrideDelegate =
+             std::weak_ptr<const AnimatedMountingOverrideDelegate>(
+                 animatedMountingOverrideDelegate_)](
+            const ShadowTree& shadowTree, bool& /*stop*/) {
+          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+              animatedMountingOverrideDelegate);
+        });
 
-    uiManager->setNativeAnimatedDelegate(nativeAnimatedDelegate_);
+    // Register on surfaces started in the future
+    uiManager->setOnSurfaceStartCallback(
+        [animatedMountingOverrideDelegate =
+             std::weak_ptr<const AnimatedMountingOverrideDelegate>(
+                 animatedMountingOverrideDelegate_)](
+            const ShadowTree& shadowTree) {
+          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+              animatedMountingOverrideDelegate);
+        });
 
-    if (!ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
-      animatedMountingOverrideDelegate_ =
-          std::make_shared<AnimatedMountingOverrideDelegate>(
-              *nativeAnimatedNodesManager_, *scheduler);
-
-      // Register on existing surfaces
-      uiManager->getShadowTreeRegistry().enumerate(
-          [animatedMountingOverrideDelegate =
-               std::weak_ptr<const AnimatedMountingOverrideDelegate>(
-                   animatedMountingOverrideDelegate_)](
-              const ShadowTree& shadowTree, bool& /*stop*/) {
-            shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
-                animatedMountingOverrideDelegate);
-          });
-      // Register on surfaces started in the future
-      uiManager->setOnSurfaceStartCallback(
-          [animatedMountingOverrideDelegate =
-               std::weak_ptr<const AnimatedMountingOverrideDelegate>(
-                   animatedMountingOverrideDelegate_)](
-              const ShadowTree& shadowTree) {
-            shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
-                animatedMountingOverrideDelegate);
-          });
-    }
+    uiManager->setNativeAnimatedDelegate(nativeAnimatedDelegate_);
+  } else {
+    // === PATH 2: Shared AnimationBackend (useSharedAnimatedBackend = true) ===
+    // Uses the shared AnimationBackend from UIManager. The backend handles all
+    // animation commits and platform integration internally.
+
+    auto animationBackend = uiManager->unstable_getAnimationBackend().lock();
+    react_native_assert(
+        animationBackend != nullptr && "animationBackend is nullptr");
+    animationBackend->registerJSInvoker(jsInvoker);
+
+    nativeAnimatedNodesManager_ =
+        std::make_shared<NativeAnimatedNodesManager>(animationBackend);
   }
+
+  addEventEmitterListener(
+      nativeAnimatedNodesManager_->getEventEmitterListener());
+
+  uiManager->addEventListener(
+      std::make_shared<EventListener>(
+          [eventEmitterListenerContainerWeak =
+               std::weak_ptr<EventEmitterListenerContainer>(
+                   eventEmitterListenerContainer_)](const RawEvent& rawEvent) {
+            const auto& eventTarget = rawEvent.eventTarget;
+            const auto& eventPayload = rawEvent.eventPayload;
+            if (eventTarget && eventPayload) {
+              if (auto eventEmitterListenerContainer =
+                      eventEmitterListenerContainerWeak.lock();
+                  eventEmitterListenerContainer != nullptr) {
+                return eventEmitterListenerContainer->willDispatchEvent(
+                    eventTarget->getTag(), rawEvent.type, *eventPayload);
+              }
+            }
+            return false;
+          }));
+
   return nativeAnimatedNodesManager_;
 }
 

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManagerProvider.h

@@ -32,7 +32,6 @@ class NativeAnimatedNodesManagerProvider {
   std::shared_ptr<EventEmitterListener> getEventEmitterListener();
 
  private:
-  std::shared_ptr<UIManagerAnimationBackend> animationBackend_;
   std::shared_ptr<NativeAnimatedNodesManager> nativeAnimatedNodesManager_;
 
   std::shared_ptr<EventEmitterListenerContainer> eventEmitterListenerContainer_;

package/ReactCommon/react/renderer/animated/event_drivers/EventAnimationDriver.h

@@ -11,7 +11,6 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <react/renderer/core/EventPayload.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <optional>

package/ReactCommon/react/renderer/animated/internal/AnimatedMountingOverrideDelegate.h

@@ -7,11 +7,9 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/MountingTransaction.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
-#include <functional>
 #include <optional>
 
 namespace facebook::react {

package/ReactCommon/react/renderer/animated/internal/NativeAnimatedAllowlist.h

@@ -12,14 +12,14 @@
 
 namespace facebook::react {
 
-inline static std::unordered_set<std::string> getDirectManipulationAllowlist()
+inline const std::unordered_set<std::string> &getDirectManipulationAllowlist()
 {
   /**
    * Direct manipulation eligible styles allowed by the NativeAnimated JS
    * implementation. Keep in sync with
    * packages/react-native/Libraries/Animated/NativeAnimatedAllowlist.js
    */
-  static std::unordered_set<std::string> DIRECT_MANIPULATION_STYLES{
+  static const std::unordered_set<std::string> DIRECT_MANIPULATION_STYLES{
       /* SUPPORTED_COLOR_STYLES */
       "backgroundColor",
       "borderBottomColor",

package/ReactCommon/react/renderer/animated/nodes/PropsAnimatedNode.cpp

@@ -12,6 +12,7 @@
 #include "PropsAnimatedNode.h"
 
 #include <react/debug/react_native_assert.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/animated/NativeAnimatedNodesManager.h>
 #include <react/renderer/animated/nodes/ColorAnimatedNode.h>
 #include <react/renderer/animated/nodes/ObjectAnimatedNode.h>
@@ -55,6 +56,15 @@ PropsAnimatedNode::PropsAnimatedNode(
   }
 }
 
+void PropsAnimatedNode::connectToShadowNodeFamily(
+    ShadowNodeFamily::Weak shadowNodeFamily) {
+  shadowNodeFamily_ = std::move(shadowNodeFamily);
+}
+
+void PropsAnimatedNode::disconnectFromShadowNodeFamily() {
+  shadowNodeFamily_.reset();
+}
+
 void PropsAnimatedNode::connectToView(Tag viewTag) {
   react_native_assert(
       connectedViewTag_ == animated::undefinedAnimatedNodeIdentifier &&
@@ -74,8 +84,17 @@ void PropsAnimatedNode::disconnectFromView(Tag viewTag) {
 void PropsAnimatedNode::restoreDefaultValues() {
   // If node is already disconnected from View, we cannot restore default values
   if (connectedViewTag_ != animated::undefinedAnimatedNodeIdentifier) {
-    manager_->schedulePropsCommit(
-        connectedViewTag_, folly::dynamic::object(), false, false);
+    if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+      manager_->schedulePropsCommit(
+          connectedViewTag_,
+          folly::dynamic::object(),
+          false,
+          false,
+          shadowNodeFamily_);
+    } else {
+      manager_->schedulePropsCommit(
+          connectedViewTag_, folly::dynamic::object(), false, false);
+    }
   }
 }
 
@@ -147,8 +166,17 @@ void PropsAnimatedNode::update(bool forceFabricCommit) {
 
   layoutStyleUpdated_ = isLayoutStyleUpdated(getConfig()["props"], *manager_);
 
-  manager_->schedulePropsCommit(
-      connectedViewTag_, props_, layoutStyleUpdated_, forceFabricCommit);
+  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    manager_->schedulePropsCommit(
+        connectedViewTag_,
+        props_,
+        layoutStyleUpdated_,
+        forceFabricCommit,
+        shadowNodeFamily_);
+  } else {
+    manager_->schedulePropsCommit(
+        connectedViewTag_, props_, layoutStyleUpdated_, forceFabricCommit);
+  }
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/animated/nodes/PropsAnimatedNode.h

@@ -21,6 +21,11 @@ namespace facebook::react {
 class PropsAnimatedNode final : public AnimatedNode {
  public:
   PropsAnimatedNode(Tag tag, const folly::dynamic &config, NativeAnimatedNodesManager &manager);
+
+  // Only called when `useSharedAnimatedBackend`==true
+  void connectToShadowNodeFamily(ShadowNodeFamily::Weak shadowNodeFamily);
+  void disconnectFromShadowNodeFamily();
+
   void connectToView(Tag viewTag);
   void disconnectFromView(Tag viewTag);
   void restoreDefaultValues();
@@ -51,6 +56,7 @@ class PropsAnimatedNode final : public AnimatedNode {
   bool layoutStyleUpdated_{false};
 
   Tag connectedViewTag_{animated::undefinedAnimatedNodeIdentifier};
+  ShadowNodeFamily::Weak shadowNodeFamily_;
 
   // Needed for PlatformColor resolver
   SurfaceId connectedRootTag_{animated::undefinedAnimatedNodeIdentifier};

package/ReactCommon/react/renderer/animationbackend/AnimatedPropSerializer.cpp

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <react/renderer/graphics/Transform.h>
+#include <react/renderer/graphics/TransformUtils.h>
 #include <stdexcept>
 #include "AnimatedPropsSerializer.h"
 
@@ -51,27 +53,14 @@ void packOpacity(folly::dynamic& dyn, const AnimatedPropBase& animatedProp) {
 }
 
 void packTransform(folly::dynamic& dyn, const AnimatedPropBase& animatedProp) {
-  const auto transform = get<Transform>(animatedProp);
-  const auto matrixArray = folly::dynamic::array(
-      transform.matrix[0],
-      transform.matrix[1],
-      transform.matrix[2],
-      transform.matrix[3],
-      transform.matrix[4],
-      transform.matrix[5],
-      transform.matrix[6],
-      transform.matrix[7],
-      transform.matrix[8],
-      transform.matrix[9],
-      transform.matrix[10],
-      transform.matrix[11],
-      transform.matrix[12],
-      transform.matrix[13],
-      transform.matrix[14],
-      transform.matrix[15]);
-  dyn.insert(
-      "transform",
-      folly::dynamic::array(folly::dynamic::object("matrix", matrixArray)));
+  const auto& transform = get<Transform>(animatedProp);
+  auto transformArray = folly::dynamic::array();
+
+  for (const auto& operation : transform.operations) {
+    updateTransformProps(transform, operation, transformArray);
+  }
+
+  dyn.insert("transform", transformArray);
 }
 
 std::string unitTypeToString(UnitType unit) {
@@ -562,6 +551,8 @@ void packBackfaceVisibility(
     case BackfaceVisibility::Hidden:
       visibilityStr = "hidden";
       break;
+    default:
+      throw std::runtime_error("Unknown backface visibility");
   }
   dyn.insert("backfaceVisibility", visibilityStr);
 }
@@ -692,6 +683,8 @@ void packAnimatedProp(
     case Z_INDEX:
     case DIRECTION:
       throw std::runtime_error("Tried to synchronously update layout props");
+    default:
+      throw std::runtime_error("Unknown animated prop");
   }
 }
 

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.cpp

@@ -55,7 +55,9 @@ void AnimatedPropsRegistry::update(
   }
 }
 
-std::pair<std::unordered_set<const ShadowNodeFamily*>&, SnapshotMap&>
+std::pair<
+    std::unordered_set<std::shared_ptr<const ShadowNodeFamily>>&,
+    SnapshotMap&>
 AnimatedPropsRegistry::getMap(SurfaceId surfaceId) {
   auto lock = std::lock_guard(mutex_);
   auto& [pendingMap, map, pendingFamilies, families] =

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.h

@@ -24,11 +24,11 @@ struct PropsSnapshot {
 
 struct SurfaceContext {
   std::unordered_map<Tag, std::unique_ptr<PropsSnapshot>> pendingMap, map;
-  std::unordered_set<const ShadowNodeFamily *> pendingFamilies, families;
+  std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> pendingFamilies, families;
 };
 
 struct SurfaceUpdates {
-  std::unordered_set<const ShadowNodeFamily *> families;
+  std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> families;
   std::unordered_map<Tag, AnimatedProps> propsMap;
   bool hasLayoutUpdates{false};
 };
@@ -39,7 +39,7 @@ class AnimatedPropsRegistry {
  public:
   void update(const std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates);
   void clear(SurfaceId surfaceId);
-  std::pair<std::unordered_set<const ShadowNodeFamily *> &, SnapshotMap &> getMap(SurfaceId surfaceId);
+  std::pair<std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> &, SnapshotMap &> getMap(SurfaceId surfaceId);
 
  private:
   std::unordered_map<SurfaceId, SurfaceContext> surfaceContexts_;
@@ -292,6 +292,9 @@ inline void updateProp(const PropName propName, BaseViewProps &viewProps, const
     case BACKFACE_VISIBILITY:
       viewProps.backfaceVisibility = snapshot.props.backfaceVisibility;
       break;
+
+    default:
+      throw std::runtime_error("Unknown property name");
   }
 }