Move AnimationBackend initialization from Animated

Summary:
This diff decouples AnimationBackend from Animated. Now the backend is intialized in the Scheduler, from where it's passed to UIManager. Animation frontends (such as Animated) can then obtain a reference to the backend, and use it to schedule animation frame updates. 

# Changelog
[General] [Changed] - Moved AnimationBackend initiailzation to `Scheduler`
[General] [Added] - `AnimationChoreographer` interface with an implementation for fantom tests

Differential Revision: D89663251

Author: Bartlomiej Bloniarz

packages/react-native/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -559,10 +559,8 @@ void NativeAnimatedNodesManager::startRenderCallbackIfNeeded(bool isAsync) {
   if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
 #ifdef RN_USE_ANIMATION_BACKEND
     if (auto animationBackend = animationBackend_.lock()) {
-      std::static_pointer_cast<AnimationBackend>(animationBackend)
-          ->start(
-              [this](float /*f*/) { return pullAnimationMutations(); },
-              isAsync);
+      animationBackend->start(
+          [this](float /*f*/) { return pullAnimationMutations(); }, isAsync);
     }
 #endif
 

packages/react-native/ReactCommon/react/renderer/animated/NativeAnimatedNodesManagerProvider.cpp

@@ -88,24 +88,17 @@ 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,
-          jsInvoker);
+      auto animationBackend = uiManager->unstable_getAnimationBackend().lock();
+      react_native_assert(
+          animationBackend != nullptr && "animationBackend is nullptr");
+      animationBackend->registerJSInvoker(jsInvoker);
 
       nativeAnimatedNodesManager_ =
-          std::make_shared<NativeAnimatedNodesManager>(animationBackend_);
+          std::make_shared<NativeAnimatedNodesManager>(animationBackend);
 
       nativeAnimatedDelegate_ =
           std::make_shared<UIManagerNativeAnimatedDelegateBackendImpl>(
-              animationBackend_);
-
-      uiManager->unstable_setAnimationBackend(animationBackend_);
+              animationBackend);
 #endif
     } else {
       nativeAnimatedNodesManager_ =

packages/react-native/ReactCommon/react/renderer/animated/NativeAnimatedNodesManagerProvider.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/animated/MergedValueDispatcher.h>
+#include <react/renderer/uimanager/UIManagerAnimationBackend.h>
 #include <react/renderer/uimanager/UIManagerNativeAnimatedDelegate.h>
 #include "NativeAnimatedNodesManager.h"
 
@@ -32,7 +33,6 @@ class NativeAnimatedNodesManagerProvider {
   std::shared_ptr<EventEmitterListener> getEventEmitterListener();
 
  private:
-  std::shared_ptr<UIManagerAnimationBackend> animationBackend_;
   std::shared_ptr<NativeAnimatedNodesManager> nativeAnimatedNodesManager_;
 
   std::shared_ptr<EventEmitterListenerContainer> eventEmitterListenerContainer_;

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

@@ -15,15 +15,6 @@
 
 namespace facebook::react {
 
-static const auto layoutProps = std::set<PropName>{
-    WIDTH,           HEIGHT,        FLEX,          MARGIN,      PADDING,
-    POSITION,        BORDER_WIDTH,  ALIGN_CONTENT, ALIGN_ITEMS, ALIGN_SELF,
-    ASPECT_RATIO,    BOX_SIZING,    DISPLAY,       FLEX_BASIS,  FLEX_DIRECTION,
-    ROW_GAP,         COLUMN_GAP,    FLEX_GROW,     FLEX_SHRINK, FLEX_WRAP,
-    JUSTIFY_CONTENT, MAX_HEIGHT,    MAX_WIDTH,     MIN_HEIGHT,  MIN_WIDTH,
-    STYLE_OVERFLOW,  POSITION_TYPE, DIRECTION,     Z_INDEX,
-};
-
 UIManagerNativeAnimatedDelegateBackendImpl::
     UIManagerNativeAnimatedDelegateBackendImpl(
         std::weak_ptr<UIManagerAnimationBackend> animationBackend)
@@ -61,20 +52,15 @@ static inline Props::Shared cloneProps(
 }
 
 AnimationBackend::AnimationBackend(
-    StartOnRenderCallback&& startOnRenderCallback,
-    StopOnRenderCallback&& stopOnRenderCallback,
     DirectManipulationCallback&& directManipulationCallback,
-    FabricCommitCallback&& fabricCommitCallback,
-    UIManager* uiManager,
-    std::shared_ptr<CallInvoker> jsInvoker)
-    : startOnRenderCallback_(std::move(startOnRenderCallback)),
-      stopOnRenderCallback_(std::move(stopOnRenderCallback)),
-      directManipulationCallback_(std::move(directManipulationCallback)),
-      fabricCommitCallback_(std::move(fabricCommitCallback)),
+    std::shared_ptr<UIManager> uiManager)
+    : directManipulationCallback_(std::move(directManipulationCallback)),
       animatedPropsRegistry_(std::make_shared<AnimatedPropsRegistry>()),
       uiManager_(uiManager),
-      jsInvoker_(std::move(jsInvoker)),
-      commitHook_(uiManager, animatedPropsRegistry_) {}
+      commitHook_(uiManager, animatedPropsRegistry_) {
+  react_native_assert(directManipulationCallback_ != nullptr);
+  react_native_assert(uiManager_ != nullptr);
+}
 
 void AnimationBackend::onAnimationFrame(double timestamp) {
   std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
@@ -110,21 +96,18 @@ void AnimationBackend::onAnimationFrame(double timestamp) {
 
 void AnimationBackend::start(const Callback& callback, bool isAsync) {
   callbacks.push_back(callback);
-  // TODO: startOnRenderCallback_ should provide the timestamp from the
-  // platform
-  if (startOnRenderCallback_) {
-    startOnRenderCallback_(
-        [this]() {
-          onAnimationFrame(
-              std::chrono::steady_clock::now().time_since_epoch().count() /
-              1000);
-        },
-        isAsync);
+  if (!isRenderCallbackStarted_) {
+    auto delegate = uiManager_->getDelegate();
+    delegate->uiManagerShouldResumeAnimationBackend();
+    isRenderCallbackStarted_ = true;
   }
 }
+
 void AnimationBackend::stop(bool isAsync) {
-  if (stopOnRenderCallback_) {
-    stopOnRenderCallback_(isAsync);
+  if (isRenderCallbackStarted_) {
+    auto delegate = uiManager_->getDelegate();
+    delegate->uiManagerShouldPauseAnimationBackend();
+    isRenderCallbackStarted_ = false;
   }
   callbacks.clear();
 }
@@ -178,6 +161,9 @@ void AnimationBackend::synchronouslyUpdateProps(
 
 void AnimationBackend::requestAsyncFlushForSurfaces(
     const std::set<SurfaceId>& surfaces) {
+  react_native_assert(
+      jsInvoker_ != nullptr ||
+      surfaces.empty() && "jsInvoker_ was not provided");
   for (const auto& surfaceId : surfaces) {
     // perform an empty commit on the js thread, to force the commit hook to
     // push updated shadow nodes to react through RSNRU
@@ -199,4 +185,11 @@ void AnimationBackend::clearRegistry(SurfaceId surfaceId) {
   animatedPropsRegistry_->clear(surfaceId);
 }
 
+void AnimationBackend::registerJSInvoker(
+    std::shared_ptr<CallInvoker> jsInvoker) {
+  if (!jsInvoker_) {
+    jsInvoker_ = jsInvoker;
+  }
+}
+
 } // namespace facebook::react

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

@@ -50,36 +50,28 @@ struct AnimationMutations {
 class AnimationBackend : public UIManagerAnimationBackend {
  public:
   using Callback = std::function<AnimationMutations(float)>;
-  using StartOnRenderCallback = std::function<void(std::function<void()> &&, bool /* isAsync */)>;
-  using StopOnRenderCallback = std::function<void(bool /* isAsync */)>;
+  using ResumeCallback = std::function<void()>;
+  using PauseCallback = std::function<void()>;
   using DirectManipulationCallback = std::function<void(Tag, const folly::dynamic &)>;
-  using FabricCommitCallback = std::function<void(std::unordered_map<Tag, folly::dynamic> &)>;
 
   std::vector<Callback> callbacks;
-  const StartOnRenderCallback startOnRenderCallback_;
-  const StopOnRenderCallback stopOnRenderCallback_;
   const DirectManipulationCallback directManipulationCallback_;
-  const FabricCommitCallback fabricCommitCallback_;
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
-  UIManager *uiManager_;
+  std::shared_ptr<UIManager> uiManager_;
   std::shared_ptr<CallInvoker> jsInvoker_;
   AnimationBackendCommitHook commitHook_;
+  bool isRenderCallbackStarted_{false};
 
-  AnimationBackend(
-      StartOnRenderCallback &&startOnRenderCallback,
-      StopOnRenderCallback &&stopOnRenderCallback,
-      DirectManipulationCallback &&directManipulationCallback,
-      FabricCommitCallback &&fabricCommitCallback,
-      UIManager *uiManager,
-      std::shared_ptr<CallInvoker> jsInvoker);
+  AnimationBackend(DirectManipulationCallback &&directManipulationCallback, std::shared_ptr<UIManager> uiManager);
   void commitUpdates(SurfaceId surfaceId, SurfaceUpdates &surfaceUpdates);
   void synchronouslyUpdateProps(const std::unordered_map<Tag, AnimatedProps> &updates);
   void requestAsyncFlushForSurfaces(const std::set<SurfaceId> &surfaces);
   void clearRegistry(SurfaceId surfaceId) override;
+  void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) override;
 
   void onAnimationFrame(double timestamp) override;
   void trigger() override;
-  void start(const Callback &callback, bool isAsync);
+  void start(const Callback &callback, bool isAsync) override;
   void stop(bool isAsync) override;
 };
 } // namespace facebook::react

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

@@ -10,10 +10,11 @@
 namespace facebook::react {
 
 AnimationBackendCommitHook::AnimationBackendCommitHook(
-    UIManager* uiManager,
+    std::shared_ptr<UIManager> uiManager,
     std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry)
-    : animatedPropsRegistry_(std::move(animatedPropsRegistry)) {
-  uiManager->registerCommitHook(*this);
+    : uiManager_(uiManager),
+      animatedPropsRegistry_(std::move(animatedPropsRegistry)) {
+  uiManager_->registerCommitHook(*this);
 }
 
 RootShadowNode::Unshared AnimationBackendCommitHook::shadowTreeWillCommit(
@@ -73,4 +74,8 @@ RootShadowNode::Unshared AnimationBackendCommitHook::shadowTreeWillCommit(
           }));
 }
 
+AnimationBackendCommitHook::~AnimationBackendCommitHook() {
+  uiManager_->unregisterCommitHook(*this);
+}
+
 } // namespace facebook::react

packages/react-native/ReactCommon/react/renderer/animationbackend/AnimationBackendCommitHook.h

@@ -16,17 +16,21 @@
 namespace facebook::react {
 
 class AnimationBackendCommitHook : public UIManagerCommitHook {
+  std::shared_ptr<UIManager> uiManager_;
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
 
  public:
-  AnimationBackendCommitHook(UIManager *uiManager, std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry);
+  AnimationBackendCommitHook(
+      std::shared_ptr<UIManager> uiManager,
+      std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry);
   RootShadowNode::Unshared shadowTreeWillCommit(
       const ShadowTree &shadowTree,
       const RootShadowNode::Shared &oldRootShadowNode,
       const RootShadowNode::Unshared &newRootShadowNode,
       const ShadowTreeCommitOptions &commitOptions) noexcept override;
   void commitHookWasRegistered(const UIManager &uiManager) noexcept override {}
   void commitHookWasUnregistered(const UIManager &uiManager) noexcept override {}
+  ~AnimationBackendCommitHook() override;
 };
 
 } // namespace facebook::react

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

@@ -55,6 +55,15 @@ Scheduler::Scheduler(
   auto uiManager =
       std::make_shared<UIManager>(runtimeExecutor_, contextContainer_);
 
+  auto directManipulationCallback = [delegate](
+                                        Tag tag, const folly::dynamic& props) {
+    delegate->schedulerShouldSynchronouslyUpdateViewOnUIThread(tag, props);
+  };
+
+  animationBackend_ = std::make_shared<AnimationBackend>(
+      std::move(directManipulationCallback), uiManager);
+  uiManager->unstable_setAnimationBackend(animationBackend_);
+
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
 
@@ -168,6 +177,8 @@ Scheduler::~Scheduler() {
     uiManager_->unregisterCommitHook(*commitHook);
   }
 
+  animationBackend_ = nullptr;
+
   // All Surfaces must be explicitly stopped before destroying `Scheduler`.
   // The idea is that `UIManager` is allowed to call `Scheduler` only if the
   // corresponding `ShadowTree` instance exists.
@@ -355,6 +366,18 @@ void Scheduler::uiManagerShouldRemoveEventListener(
   removeEventListener(listener);
 }
 
+void Scheduler::uiManagerShouldResumeAnimationBackend() {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerShouldResumeAnimationFrameCallbacks();
+  }
+}
+
+void Scheduler::uiManagerShouldPauseAnimationBackend() {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerShouldPauseAnimationFrameCallbacks();
+  }
+}
+
 void Scheduler::uiManagerDidStartSurface(const ShadowTree& shadowTree) {
   std::shared_lock lock(onSurfaceStartCallbackMutex_);
   if (onSurfaceStartCallback_) {

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

@@ -13,6 +13,7 @@
 #include <react/performance/cdpmetrics/CdpMetricsReporter.h>
 #include <react/performance/cdpmetrics/CdpPerfIssuesReporter.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
+#include <react/renderer/animationbackend/AnimationBackend.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/EventEmitter.h>
@@ -46,8 +47,6 @@ class Scheduler final : public UIManagerDelegate {
 
   /*
    * Registers and unregisters a `SurfaceHandler` object in the `Scheduler`.
-   * All registered `SurfaceHandler` objects must be unregistered
-   * (with the same `Scheduler`) before their deallocation.
    */
   void registerSurface(const SurfaceHandler &surfaceHandler) const noexcept;
   void unregisterSurface(const SurfaceHandler &surfaceHandler) const noexcept;
@@ -97,6 +96,8 @@ class Scheduler final : public UIManagerDelegate {
   void uiManagerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
   void uiManagerShouldAddEventListener(std::shared_ptr<const EventListener> listener) final;
   void uiManagerShouldRemoveEventListener(const std::shared_ptr<const EventListener> &listener) final;
+  void uiManagerShouldResumeAnimationBackend() override;
+  void uiManagerShouldPauseAnimationBackend() override;
   void uiManagerDidStartSurface(const ShadowTree &shadowTree) override;
 
 #pragma mark - ContextContainer
@@ -148,6 +149,7 @@ class Scheduler final : public UIManagerDelegate {
 
   mutable std::shared_mutex onSurfaceStartCallbackMutex_;
   OnSurfaceStartCallback onSurfaceStartCallback_;
+  std::shared_ptr<AnimationBackend> animationBackend_;
 };
 
 } // namespace facebook::react

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

@@ -437,8 +437,8 @@ void UIManager::setNativeProps_DEPRECATED(
   if (family.nativeProps_DEPRECATED) {
     // Values in `rawProps` patch (take precedence over)
     // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
-    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what was
-    // previously in `nativeProps_DEPRECATED`.
+    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what
+    // was previously in `nativeProps_DEPRECATED`.
     family.nativeProps_DEPRECATED =
         std::make_unique<folly::dynamic>(mergeDynamicProps(
             *family.nativeProps_DEPRECATED,
@@ -529,9 +529,9 @@ std::shared_ptr<const ShadowNode> UIManager::findShadowNodeByTag_DEPRECATED(
     // pointer to a root node because of the possible data race.
     // To work around this, we ask for a commit and immediately cancel it
     // returning `nullptr` instead of a new shadow tree.
-    // We don't want to add a way to access a stored pointer to a root node
-    // because this `findShadowNodeByTag` is deprecated. It is only added
-    // to make migration to the new architecture easier.
+    // We don't want to add a way to access a stored pointer to a root
+    // node because this `findShadowNodeByTag` is deprecated. It is only
+    // added to make migration to the new architecture easier.
     shadowTree.tryCommit(
         [&](const RootShadowNode& oldRootShadowNode) {
           rootShadowNode = &oldRootShadowNode;
@@ -687,12 +687,14 @@ void UIManager::setNativeAnimatedDelegate(
 }
 
 void UIManager::unstable_setAnimationBackend(
-    std::weak_ptr<UIManagerAnimationBackend> animationBackend) {
+    std::shared_ptr<UIManagerAnimationBackend> animationBackend) {
   animationBackend_ = animationBackend;
 }
 
 std::weak_ptr<UIManagerAnimationBackend>
 UIManager::unstable_getAnimationBackend() {
+  react_native_assert(
+      !animationBackend_.expired() && "Animation Backend was not initialized");
   return animationBackend_;
 }