react-native-tvos 0.85.3-0 → 0.86.0-0rc2

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.cpp

@@ -65,12 +65,13 @@ void UIManagerBinding::dispatchEvent(
     EventTarget* eventTarget,
     const std::string& type,
     ReactEventPriority priority,
-    const EventPayload& eventPayload) const {
+    const EventPayload& eventPayload,
+    HighResTimeStamp eventTimestamp) const {
   TraceSection s("UIManagerBinding::dispatchEvent", "type", type);
 
   if (eventPayload.getType() == EventPayloadType::PointerEvent) {
     auto pointerEvent = static_cast<const PointerEvent&>(eventPayload);
-    auto dispatchCallback = [this, &runtime](
+    auto dispatchCallback = [this, &runtime, eventTimestamp](
                                 const ShadowNode& targetNode,
                                 const std::string& type,
                                 ReactEventPriority priority,
@@ -79,7 +80,12 @@ void UIManagerBinding::dispatchEvent(
       if (eventTarget != nullptr) {
         eventTarget->retain(runtime);
         this->dispatchEventToJS(
-            runtime, eventTarget.get(), type, priority, eventPayload);
+            runtime,
+            eventTarget.get(),
+            type,
+            priority,
+            eventPayload,
+            eventTimestamp);
         eventTarget->release(runtime);
       }
     };
@@ -95,7 +101,8 @@ void UIManagerBinding::dispatchEvent(
           *uiManager_);
     }
   } else {
-    dispatchEventToJS(runtime, eventTarget, type, priority, eventPayload);
+    dispatchEventToJS(
+        runtime, eventTarget, type, priority, eventPayload, eventTimestamp);
   }
 }
 
@@ -104,7 +111,8 @@ void UIManagerBinding::dispatchEventToJS(
     EventTarget* eventTarget,
     const std::string& type,
     ReactEventPriority priority,
-    const EventPayload& eventPayload) const {
+    const EventPayload& eventPayload,
+    HighResTimeStamp eventTimestamp) const {
   auto payload = eventPayload.asJSIValue(runtime);
 
   // If a payload is null, the factory has decided to cancel the event
@@ -136,6 +144,15 @@ void UIManagerBinding::dispatchEventToJS(
                           << " will be dropped";
   }
 
+  // Add timestamp to payload if not already set
+  if (payload.isObject()) {
+    auto payloadObject = payload.asObject(runtime);
+    if (!payloadObject.hasProperty(runtime, "timeStamp")) {
+      payloadObject.setProperty(
+          runtime, "timeStamp", eventTimestamp.toDOMHighResTimeStamp());
+    }
+  }
+
   currentEventPriority_ = priority;
   if (eventHandler_) {
     eventHandler_->call(
@@ -876,6 +893,331 @@ jsi::Value UIManagerBinding::get(
         });
   }
 
+  if (methodName == "measureInstance") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          if (!arguments[0].isObject()) {
+            auto result = jsi::Object(runtime);
+            result.setProperty(runtime, "x", 0);
+            result.setProperty(runtime, "y", 0);
+            result.setProperty(runtime, "width", 0);
+            result.setProperty(runtime, "height", 0);
+            return result;
+          }
+
+          auto shadowNode = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+              runtime, arguments[0]);
+
+          auto currentRevision =
+              uiManager->getShadowTreeRevisionProvider()->getCurrentRevision(
+                  shadowNode->getSurfaceId());
+
+          if (currentRevision == nullptr) {
+            auto result = jsi::Object(runtime);
+            result.setProperty(runtime, "x", 0);
+            result.setProperty(runtime, "y", 0);
+            result.setProperty(runtime, "width", 0);
+            result.setProperty(runtime, "height", 0);
+            return result;
+          }
+
+          auto domRect = dom::getBoundingClientRect(
+              currentRevision, *shadowNode, true /* includeTransform */);
+
+          auto result = jsi::Object(runtime);
+          result.setProperty(runtime, "x", domRect.x);
+          result.setProperty(runtime, "y", domRect.y);
+          result.setProperty(runtime, "width", domRect.width);
+          result.setProperty(runtime, "height", domRect.height);
+
+          return result;
+        });
+  }
+
+  if (methodName == "applyViewTransitionName") {
+    auto paramCount = 3;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          if (arguments[0].isObject()) {
+            auto shadowNode =
+                Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+                    runtime, arguments[0]);
+            auto transitionName = arguments[1].isString()
+                ? stringFromValue(runtime, arguments[1])
+                : "";
+            auto className = arguments[2].isString()
+                ? stringFromValue(runtime, arguments[2])
+                : "";
+            if (!transitionName.empty()) {
+              auto* viewTransitionDelegate =
+                  uiManager->getViewTransitionDelegate();
+              if (viewTransitionDelegate != nullptr) {
+                viewTransitionDelegate->applyViewTransitionName(
+                    *shadowNode, transitionName, className);
+              }
+            }
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "createViewTransitionInstance") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto transitionName = arguments[0].isString()
+              ? stringFromValue(runtime, arguments[0])
+              : "";
+          auto pseudoElementTag = tagFromValue(arguments[1]);
+
+          if (!transitionName.empty()) {
+            auto* viewTransitionDelegate =
+                uiManager->getViewTransitionDelegate();
+            if (viewTransitionDelegate != nullptr) {
+              viewTransitionDelegate->createViewTransitionInstance(
+                  transitionName, pseudoElementTag);
+            }
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "cancelViewTransitionName") {
+    auto paramCount = 2;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          if (arguments[0].isObject()) {
+            auto shadowNode =
+                Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+                    runtime, arguments[0]);
+            auto transitionName = arguments[1].isString()
+                ? stringFromValue(runtime, arguments[1])
+                : "";
+            if (!transitionName.empty()) {
+              auto* viewTransitionDelegate =
+                  uiManager->getViewTransitionDelegate();
+              if (viewTransitionDelegate != nullptr) {
+                viewTransitionDelegate->cancelViewTransitionName(
+                    *shadowNode, transitionName);
+              }
+            }
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "restoreViewTransitionName") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          if (arguments[0].isObject()) {
+            auto shadowNode =
+                Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+                    runtime, arguments[0]);
+            auto* viewTransitionDelegate =
+                uiManager->getViewTransitionDelegate();
+            if (viewTransitionDelegate != nullptr) {
+              viewTransitionDelegate->restoreViewTransitionName(*shadowNode);
+            }
+          }
+
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "suspendOnActiveViewTransition") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [uiManager](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* /*arguments*/,
+            size_t /*count*/) -> jsi::Value {
+          auto* viewTransitionDelegate = uiManager->getViewTransitionDelegate();
+          if (viewTransitionDelegate != nullptr) {
+            viewTransitionDelegate->suspendOnActiveViewTransition();
+          }
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "startViewTransitionReadyFinished") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [uiManager](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* /*arguments*/,
+            size_t /*count*/) -> jsi::Value {
+          auto* viewTransitionDelegate = uiManager->getViewTransitionDelegate();
+          if (viewTransitionDelegate != nullptr) {
+            viewTransitionDelegate->startViewTransitionReadyFinished();
+          }
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (methodName == "startViewTransition") {
+    auto paramCount = 1;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        paramCount,
+        [uiManager, methodName, paramCount](
+            jsi::Runtime& runtime,
+            const jsi::Value& /*thisValue*/,
+            const jsi::Value* arguments,
+            size_t count) -> jsi::Value {
+          validateArgumentCount(runtime, methodName, paramCount, count);
+
+          auto* viewTransitionDelegate = uiManager->getViewTransitionDelegate();
+          if (viewTransitionDelegate == nullptr) {
+            return jsi::Value::undefined();
+          }
+
+          auto promiseConstructor =
+              runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+          std::shared_ptr<jsi::Function> readyResolveFunc;
+          std::shared_ptr<jsi::Function> finishedResolveFunc;
+
+          auto mutationFunc = std::make_shared<jsi::Function>(
+              arguments[0].asObject(runtime).asFunction(runtime));
+
+          auto readyPromise = promiseConstructor.callAsConstructor(
+              runtime,
+              jsi::Function::createFromHostFunction(
+                  runtime,
+                  jsi::PropNameID::forAscii(runtime, "readyExecutor"),
+                  2,
+                  [&readyResolveFunc](
+                      jsi::Runtime& runtime,
+                      const jsi::Value& /*thisValue*/,
+                      const jsi::Value* args,
+                      size_t /*count*/) -> jsi::Value {
+                    readyResolveFunc = std::make_shared<jsi::Function>(
+                        args[0].asObject(runtime).asFunction(runtime));
+                    return jsi::Value::undefined();
+                  }));
+
+          auto finishedPromise = promiseConstructor.callAsConstructor(
+              runtime,
+              jsi::Function::createFromHostFunction(
+                  runtime,
+                  jsi::PropNameID::forAscii(runtime, "finishedExecutor"),
+                  2,
+                  [&finishedResolveFunc, viewTransitionDelegate](
+                      jsi::Runtime& rt,
+                      const jsi::Value& /*thisValue*/,
+                      const jsi::Value* args,
+                      size_t /*count*/) mutable -> jsi::Value {
+                    auto onCompleteFunc = std::make_shared<jsi::Function>(
+                        args[0].asObject(rt).asFunction(rt));
+                    finishedResolveFunc = std::make_shared<jsi::Function>(
+                        jsi::Function::createFromHostFunction(
+                            rt,
+                            jsi::PropNameID::forAscii(rt, "finishedResolve"),
+                            0,
+                            [onCompleteFunc = std::move(onCompleteFunc),
+                             viewTransitionDelegate =
+                                 std::move(viewTransitionDelegate)](
+                                jsi::Runtime& runtime,
+                                const jsi::Value& /*thisValue*/,
+                                const jsi::Value* /*args*/,
+                                size_t /*count*/) -> jsi::Value {
+                              onCompleteFunc->call(runtime);
+                              viewTransitionDelegate->startViewTransitionEnd();
+                              return jsi::Value::undefined();
+                            }));
+                    return jsi::Value::undefined();
+                  }));
+
+          auto result = jsi::Object(runtime);
+          result.setProperty(runtime, "ready", std::move(readyPromise));
+          result.setProperty(runtime, "finished", std::move(finishedPromise));
+
+          viewTransitionDelegate->startViewTransition(
+              [&runtime, mutationFunc = std::move(mutationFunc)]() {
+                // mutationCallback is called synchronously by the
+                // delegate during startViewTransition, so &runtime is
+                // valid (it comes from the enclosing host function).
+                mutationFunc->call(runtime);
+              },
+              [readyResolveFunc = std::move(readyResolveFunc), &runtime]() {
+                // onReadyCallback is called synchronously on the JS
+                // thread by the delegate, so &runtime is valid.
+                if (readyResolveFunc) {
+                  readyResolveFunc->call(runtime);
+                }
+              },
+              [finishedResolveFunc = std::move(finishedResolveFunc),
+               runtimeExecutor = uiManager->runtimeExecutor_]() {
+                runtimeExecutor(
+                    [finishedResolveFunc = std::move(finishedResolveFunc)](
+                        jsi::Runtime& rt) mutable {
+                      if (finishedResolveFunc) {
+                        finishedResolveFunc->call(rt);
+                      }
+                    });
+              });
+
+          return jsi::Value(runtime, result);
+        });
+  }
+
   return jsi::Value::undefined();
 }
 

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.h

@@ -7,12 +7,12 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <jsi/jsi.h>
 #include <react/renderer/core/RawValue.h>
 #include <react/renderer/uimanager/PointerEventsProcessor.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/primitives.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -47,7 +47,8 @@ class UIManagerBinding : public jsi::HostObject {
       EventTarget *eventTarget,
       const std::string &type,
       ReactEventPriority priority,
-      const EventPayload &payload) const;
+      const EventPayload &payload,
+      HighResTimeStamp eventTimestamp) const;
 
   /*
    * Invalidates the binding and underlying UIManager.
@@ -76,7 +77,8 @@ class UIManagerBinding : public jsi::HostObject {
       EventTarget *eventTarget,
       const std::string &type,
       ReactEventPriority priority,
-      const EventPayload &payload) const;
+      const EventPayload &payload,
+      HighResTimeStamp eventTimestamp) const;
 
   std::shared_ptr<UIManager> uiManager_;
   std::unique_ptr<jsi::Function> eventHandler_;

package/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -97,6 +97,11 @@ class UIManagerDelegate {
   using OnSurfaceStartCallback = std::function<void(const ShadowTree &shadowTree)>;
   virtual void uiManagerShouldSetOnSurfaceStartCallback(OnSurfaceStartCallback &&callback) = 0;
 
+  // View transition bitmap snapshot capture and application.
+  virtual void uiManagerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) = 0;
+  virtual void uiManagerDidSetViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId) = 0;
+  virtual void uiManagerDidClearPendingSnapshots() = 0;
+
   virtual ~UIManagerDelegate() noexcept = default;
 };
 

package/ReactCommon/react/renderer/uimanager/UIManagerViewTransitionDelegate.h

@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/graphics/Float.h>
+#include <functional>
+#include <optional>
+
+namespace facebook::react {
+
+class UIManagerViewTransitionDelegate {
+ public:
+  virtual ~UIManagerViewTransitionDelegate() = default;
+
+  virtual void
+  applyViewTransitionName(const ShadowNode &shadowNode, const std::string &name, const std::string &className)
+  {
+  }
+
+  virtual void createViewTransitionInstance(const std::string & /*name*/, Tag /*pseudoElementTag*/) {}
+
+  virtual void cancelViewTransitionName(const ShadowNode &shadowNode, const std::string &name) {}
+
+  virtual void restoreViewTransitionName(const ShadowNode &shadowNode) {}
+
+  /*
+   * Start a view transition. mutationCallback and onReadyCallback MUST be
+   * called from a thread with access to the jsi::Runtime.
+   * onCompleteCallback may be called from any thread.
+   */
+  virtual void startViewTransition(
+      std::function<void()> mutationCallback,
+      std::function<void()> onReadyCallback,
+      std::function<void()> onCompleteCallback)
+  {
+  }
+
+  virtual void startViewTransitionReadyFinished() {}
+
+  virtual void startViewTransitionEnd() {}
+
+  struct ViewTransitionInstance {
+    Float x{0};
+    Float y{0};
+    Float width{0};
+    Float height{0};
+    Tag nativeTag{-1};
+  };
+
+  virtual std::optional<ViewTransitionInstance> getViewTransitionInstance(
+      const std::string &name,
+      const std::string &pseudo)
+  {
+    return std::nullopt;
+  }
+
+  // Similar to UIManager::findShadowNodeByTag, but searches all direct children
+  // of the root node (where pseudo-element nodes live) rather than just the
+  // first child. Pseudo-element nodes are appended as additional children of the
+  // root node, rather than inserted into the main React tree, to avoid
+  // disrupting the user-created component tree.
+  virtual std::shared_ptr<const ShadowNode> findPseudoElementShadowNodeByTag(Tag /*tag*/) const
+  {
+    return nullptr;
+  }
+
+  // Called by the reconciler to signal that the next view transition should
+  // be suspended until the currently active one finishes.
+  virtual void suspendOnActiveViewTransition() {}
+
+  virtual void waitForTransitionAnimation(int animationId) {}
+
+  virtual void transitionAnimationFinished(int animationId) {}
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/viewtransition/CMakeLists.txt

@@ -0,0 +1,22 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+file(GLOB react_renderer_viewtransition_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_renderer_viewtransition STATIC ${react_renderer_viewtransition_SRC})
+
+target_include_directories(react_renderer_viewtransition PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_renderer_viewtransition
+        glog
+        react_renderer_core
+        react_renderer_mounting
+        react_renderer_uimanager
+)
+target_compile_reactnative_options(react_renderer_viewtransition PRIVATE)