react-native-tvos 0.64.2-2 → 0.66.3-0

package/ReactCommon/react/renderer/mounting/tests/StateReconciliationTest.cpp

@@ -10,20 +10,27 @@
 #include <gtest/gtest.h>
 
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
-#include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/element/ComponentBuilder.h>
 #include <react/renderer/element/Element.h>
-#include <react/renderer/element/testUtils.h>
-
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowTree.h>
 #include <react/renderer/mounting/ShadowTreeDelegate.h>
 
+#include <react/renderer/element/testUtils.h>
+
 using namespace facebook::react;
 
 class DummyShadowTreeDelegate : public ShadowTreeDelegate {
  public:
+  virtual RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode) const override {
+    return newRootShadowNode;
+  };
+
   virtual void shadowTreeDidFinishTransaction(
       ShadowTree const &shadowTree,
       MountingCoordinator::Shared const &mountingCoordinator) const override{};
@@ -71,15 +78,20 @@ TEST(StateReconciliationTest, testStateReconciliation) {
             .reference(shadowNodeAB)
             .children({
               Element<ViewShadowNode>()
-                .reference(shadowNodeABA),
-              Element<ViewShadowNode>()
-                .reference(shadowNodeABB),
-              Element<ViewShadowNode>()
-                .reference(shadowNodeABC)
+              .children({
+                Element<ViewShadowNode>()
+                  .reference(shadowNodeABA),
+                Element<ViewShadowNode>()
+                  .reference(shadowNodeABB),
+                Element<ViewShadowNode>()
+                  .reference(shadowNodeABC)
+              })
             })
         });
   // clang-format on
 
+  ContextContainer contextContainer{};
+
   auto shadowNode = builder.build(element);
 
   auto rootShadowNodeState1 = shadowNode->ShadowNode::clone({});
@@ -88,15 +100,12 @@ TEST(StateReconciliationTest, testStateReconciliation) {
   auto &family = shadowNodeAB->getFamily();
   auto state1 = shadowNodeAB->getState();
   auto shadowTreeDelegate = DummyShadowTreeDelegate{};
-  auto eventDispatcher = EventDispatcher::Shared{};
-  auto rootComponentDescriptor =
-      ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr};
-  ShadowTree shadowTree{SurfaceId{11},
-                        LayoutConstraints{},
-                        LayoutContext{},
-                        rootComponentDescriptor,
-                        shadowTreeDelegate,
-                        {}};
+  ShadowTree shadowTree{
+      SurfaceId{11},
+      LayoutConstraints{},
+      LayoutContext{},
+      shadowTreeDelegate,
+      contextContainer};
 
   shadowTree.commit(
       [&](RootShadowNode const &oldRootShadowNode) {
@@ -114,9 +123,10 @@ TEST(StateReconciliationTest, testStateReconciliation) {
 
   auto rootShadowNodeState2 =
       shadowNode->cloneTree(family, [&](ShadowNode const &oldShadowNode) {
-        return oldShadowNode.clone({ShadowNodeFragment::propsPlaceholder(),
-                                    ShadowNodeFragment::childrenPlaceholder(),
-                                    state2});
+        return oldShadowNode.clone(
+            {ShadowNodeFragment::propsPlaceholder(),
+             ShadowNodeFragment::childrenPlaceholder(),
+             state2});
       });
 
   EXPECT_EQ(
@@ -136,9 +146,10 @@ TEST(StateReconciliationTest, testStateReconciliation) {
 
   auto rootShadowNodeState3 = rootShadowNodeState2->cloneTree(
       family, [&](ShadowNode const &oldShadowNode) {
-        return oldShadowNode.clone({ShadowNodeFragment::propsPlaceholder(),
-                                    ShadowNodeFragment::childrenPlaceholder(),
-                                    state3});
+        return oldShadowNode.clone(
+            {ShadowNodeFragment::propsPlaceholder(),
+             ShadowNodeFragment::childrenPlaceholder(),
+             state3});
       });
 
   EXPECT_EQ(

package/ReactCommon/react/renderer/runtimescheduler/Android.mk

@@ -0,0 +1,27 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := react_render_runtimescheduler
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../
+
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
+
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/../../../
+
+LOCAL_SHARED_LIBRARIES := libruntimeexecutor libreact_render_core libreact_debug libjsi
+
+LOCAL_CFLAGS := \
+  -DLOG_TAG=\"Fabric\"
+
+LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
+
+include $(BUILD_SHARED_LIBRARY)
+
+$(call import-module,runtimeexecutor)

package/ReactCommon/react/renderer/runtimescheduler/BUCK

@@ -0,0 +1,77 @@
+load(
+    "//tools/build_defs/oss:rn_defs.bzl",
+    "ANDROID",
+    "APPLE",
+    "CXX",
+    "fb_xplat_cxx_test",
+    "get_apple_compiler_flags",
+    "get_apple_inspector_flags",
+    "get_preprocessor_flags_for_build_mode",
+    "react_native_xplat_target",
+    "rn_xplat_cxx_library",
+    "subdir_glob",
+)
+
+APPLE_COMPILER_FLAGS = get_apple_compiler_flags()
+
+rn_xplat_cxx_library(
+    name = "runtimescheduler",
+    srcs = glob(
+        ["**/*.cpp"],
+        exclude = glob(["tests/**/*.cpp"]),
+    ),
+    headers = glob(
+        ["**/*.h"],
+        exclude = glob(["tests/**/*.h"]),
+    ),
+    header_namespace = "",
+    exported_headers = subdir_glob(
+        [
+            ("", "*.h"),
+        ],
+        prefix = "react/renderer/runtimescheduler",
+    ),
+    compiler_flags = [
+        "-fexceptions",
+        "-frtti",
+        "-std=c++17",
+        "-Wall",
+    ],
+    fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
+    fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
+    force_static = True,
+    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    macosx_tests_override = [],
+    platforms = (ANDROID, APPLE, CXX),
+    preprocessor_flags = [
+        "-DLOG_TAG=\"ReactNative\"",
+        "-DWITH_FBSYSTRACE=1",
+    ],
+    tests = [":tests"],
+    visibility = ["PUBLIC"],
+    deps = [
+        react_native_xplat_target("react/renderer/core:core"),
+        react_native_xplat_target("runtimeexecutor:runtimeexecutor"),
+        react_native_xplat_target("react/renderer/debug:debug"),
+        react_native_xplat_target("better:better"),
+    ],
+)
+
+fb_xplat_cxx_test(
+    name = "tests",
+    srcs = glob(["tests/*.cpp"]),
+    headers = glob(["tests/*.h"]),
+    compiler_flags = [
+        "-fexceptions",
+        "-frtti",
+        "-std=c++17",
+        "-Wall",
+    ],
+    contacts = ["oncall+react_native@xmail.facebook.com"],
+    platforms = (ANDROID, APPLE, CXX),
+    deps = [
+        react_native_xplat_target("react/renderer/runtimescheduler:runtimescheduler"),
+        "//xplat/hermes/API:HermesAPI",
+        "//xplat/third-party/gmock:gtest",
+    ],
+)

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "RuntimeScheduler.h"
+
+namespace facebook::react {
+
+#pragma mark - Public
+
+RuntimeScheduler::RuntimeScheduler(
+    RuntimeExecutor const &runtimeExecutor,
+    std::function<RuntimeSchedulerTimePoint()> now)
+    : runtimeExecutor_(runtimeExecutor), now_(now) {}
+
+void RuntimeScheduler::scheduleWork(
+    std::function<void(jsi::Runtime &)> callback) const {
+  if (enableYielding_) {
+    shouldYield_ = true;
+    runtimeExecutor_(
+        [this, callback = std::move(callback)](jsi::Runtime &runtime) {
+          shouldYield_ = false;
+          callback(runtime);
+          startWorkLoop(runtime);
+        });
+  } else {
+    runtimeExecutor_([callback = std::move(callback)](jsi::Runtime &runtime) {
+      callback(runtime);
+    });
+  }
+}
+
+std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
+    SchedulerPriority priority,
+    jsi::Function callback) {
+  auto expirationTime = now() + timeoutForSchedulerPriority(priority);
+  auto task =
+      std::make_shared<Task>(priority, std::move(callback), expirationTime);
+  taskQueue_.push(task);
+
+  if (!isCallbackScheduled_ && !isPerformingWork_) {
+    isCallbackScheduled_ = true;
+    runtimeExecutor_([this](jsi::Runtime &runtime) {
+      isCallbackScheduled_ = false;
+      startWorkLoop(runtime);
+    });
+  }
+
+  return task;
+}
+
+bool RuntimeScheduler::getShouldYield() const noexcept {
+  return shouldYield_;
+}
+
+void RuntimeScheduler::cancelTask(const std::shared_ptr<Task> &task) noexcept {
+  task->callback.reset();
+}
+
+SchedulerPriority RuntimeScheduler::getCurrentPriorityLevel() const noexcept {
+  return currentPriority_;
+}
+
+RuntimeSchedulerTimePoint RuntimeScheduler::now() const noexcept {
+  return now_();
+}
+
+void RuntimeScheduler::setEnableYielding(bool enableYielding) {
+  enableYielding_ = enableYielding;
+}
+
+void RuntimeScheduler::executeNowOnTheSameThread(
+    std::function<void(jsi::Runtime &runtime)> callback) const {
+  shouldYield_ = true;
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+      runtimeExecutor_,
+      [callback = std::move(callback)](jsi::Runtime &runtime) {
+        callback(runtime);
+      });
+  shouldYield_ = false;
+}
+
+#pragma mark - Private
+
+void RuntimeScheduler::startWorkLoop(jsi::Runtime &runtime) const {
+  auto previousPriority = currentPriority_;
+  isPerformingWork_ = true;
+  while (!taskQueue_.empty()) {
+    auto topPriorityTask = taskQueue_.top();
+    auto now = now_();
+    auto didUserCallbackTimeout = topPriorityTask->expirationTime <= now;
+
+    if (!didUserCallbackTimeout && shouldYield_) {
+      // This task hasn't expired and we need to yield.
+      break;
+    }
+    currentPriority_ = topPriorityTask->priority;
+    auto result = topPriorityTask->execute(runtime);
+
+    if (result.isObject() && result.getObject(runtime).isFunction(runtime)) {
+      topPriorityTask->callback =
+          result.getObject(runtime).getFunction(runtime);
+    } else {
+      if (taskQueue_.top() == topPriorityTask) {
+        taskQueue_.pop();
+      }
+    }
+  }
+  currentPriority_ = previousPriority;
+  isPerformingWork_ = false;
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <ReactCommon/RuntimeExecutor.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
+#include <react/renderer/runtimescheduler/Task.h>
+#include <atomic>
+#include <memory>
+#include <queue>
+
+namespace facebook::react {
+
+class RuntimeScheduler final {
+ public:
+  RuntimeScheduler(
+      RuntimeExecutor const &runtimeExecutor,
+      std::function<RuntimeSchedulerTimePoint()> now =
+          RuntimeSchedulerClock::now);
+  /*
+   * Not copyable.
+   */
+  RuntimeScheduler(RuntimeScheduler const &) = delete;
+  RuntimeScheduler &operator=(RuntimeScheduler const &) = delete;
+
+  /*
+   * Not movable.
+   */
+  RuntimeScheduler(RuntimeScheduler &&) = delete;
+  RuntimeScheduler &operator=(RuntimeScheduler &&) = delete;
+
+  void scheduleWork(std::function<void(jsi::Runtime &)> callback) const;
+
+  /*
+   * Grants access to the runtime synchronously on the caller's thread.
+   *
+   * Shouldn't be called directly. it is expected to be used
+   * by dispatching a synchronous event via event emitter in your native
+   * component.
+   */
+  void executeNowOnTheSameThread(
+      std::function<void(jsi::Runtime &runtime)> callback) const;
+
+  std::shared_ptr<Task> scheduleTask(
+      SchedulerPriority priority,
+      jsi::Function callback);
+
+  void cancelTask(std::shared_ptr<Task> const &task) noexcept;
+
+  bool getShouldYield() const noexcept;
+
+  SchedulerPriority getCurrentPriorityLevel() const noexcept;
+
+  RuntimeSchedulerTimePoint now() const noexcept;
+
+  void setEnableYielding(bool enableYielding);
+
+ private:
+  mutable std::priority_queue<
+      std::shared_ptr<Task>,
+      std::vector<std::shared_ptr<Task>>,
+      TaskPriorityComparer>
+      taskQueue_;
+
+  RuntimeExecutor const runtimeExecutor_;
+  mutable SchedulerPriority currentPriority_{SchedulerPriority::NormalPriority};
+  mutable std::atomic_bool shouldYield_{false};
+
+  void startWorkLoop(jsi::Runtime &runtime) const;
+
+  /*
+   * Returns a time point representing the current point in time. May be called
+   * from multiple threads.
+   */
+  std::function<RuntimeSchedulerTimePoint()> now_;
+
+  /*
+   * Flag indicating if callback on JavaScript queue has been
+   * scheduled.
+   */
+  std::atomic_bool isCallbackScheduled_{false};
+
+  /*
+   * Flag indicating if yielding is enabled.
+   *
+   * If set to true and Concurrent Mode is enabled on the surface,
+   * React Native will ask React to yield in case any work has been scheduled.
+   * Default value is false
+   */
+  bool enableYielding_{false};
+
+  /*
+   * This flag is set while performing work, to prevent re-entrancy.
+   */
+  mutable bool isPerformingWork_{false};
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp

@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "RuntimeSchedulerBinding.h"
+#include "SchedulerPriority.h"
+#include "primitives.h"
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <chrono>
+#include <memory>
+
+namespace facebook::react {
+
+std::shared_ptr<RuntimeSchedulerBinding>
+RuntimeSchedulerBinding::createAndInstallIfNeeded(
+    jsi::Runtime &runtime,
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler) {
+  auto runtimeSchedulerModuleName = "nativeRuntimeScheduler";
+
+  auto runtimeSchedulerValue =
+      runtime.global().getProperty(runtime, runtimeSchedulerModuleName);
+  if (runtimeSchedulerValue.isUndefined()) {
+    // The global namespace does not have an instance of the binding;
+    // we need to create, install and return it.
+    auto runtimeSchedulerBinding =
+        std::make_shared<RuntimeSchedulerBinding>(runtimeScheduler);
+    auto object =
+        jsi::Object::createFromHostObject(runtime, runtimeSchedulerBinding);
+    runtime.global().setProperty(
+        runtime, runtimeSchedulerModuleName, std::move(object));
+    return runtimeSchedulerBinding;
+  }
+
+  // The global namespace already has an instance of the binding;
+  // we need to return that.
+  auto runtimeSchedulerObject = runtimeSchedulerValue.asObject(runtime);
+  return runtimeSchedulerObject.getHostObject<RuntimeSchedulerBinding>(runtime);
+}
+
+RuntimeSchedulerBinding::RuntimeSchedulerBinding(
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
+
+jsi::Value RuntimeSchedulerBinding::get(
+    jsi::Runtime &runtime,
+    jsi::PropNameID const &name) {
+  auto propertyName = name.utf8(runtime);
+
+  if (propertyName == "unstable_scheduleCallback") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *arguments,
+            size_t) noexcept -> jsi::Value {
+          SchedulerPriority priority = fromRawValue(arguments[0].getNumber());
+          auto callback = arguments[1].getObject(runtime).getFunction(runtime);
+
+          auto task =
+              runtimeScheduler_->scheduleTask(priority, std::move(callback));
+
+          return valueFromTask(runtime, task);
+        });
+  }
+
+  if (propertyName == "unstable_cancelCallback") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [this](
+            jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *arguments,
+            size_t) noexcept -> jsi::Value {
+          runtimeScheduler_->cancelTask(taskFromValue(runtime, arguments[0]));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propertyName == "unstable_shouldYield") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [this](
+            jsi::Runtime &,
+            jsi::Value const &,
+            jsi::Value const *,
+            size_t) noexcept -> jsi::Value {
+          auto shouldYield = runtimeScheduler_->getShouldYield();
+          return jsi::Value(shouldYield);
+        });
+  }
+
+  if (propertyName == "unstable_requestPaint") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [](jsi::Runtime &,
+           jsi::Value const &,
+           jsi::Value const *,
+           size_t) noexcept -> jsi::Value {
+          // RequestPaint is left empty by design.
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propertyName == "unstable_now") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [this](
+            jsi::Runtime &,
+            jsi::Value const &,
+            jsi::Value const *,
+            size_t) noexcept -> jsi::Value {
+          auto now = runtimeScheduler_->now();
+          auto asDouble =
+              std::chrono::duration<double, std::milli>(now.time_since_epoch())
+                  .count();
+          return jsi::Value(asDouble);
+        });
+  }
+
+  if (propertyName == "unstable_getCurrentPriorityLevel") {
+    auto currentPriorityLevel = runtimeScheduler_->getCurrentPriorityLevel();
+    return jsi::Value(runtime, serialize(currentPriorityLevel));
+  }
+
+  if (propertyName == "unstable_ImmediatePriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::ImmediatePriority));
+  }
+
+  if (propertyName == "unstable_UserBlockingPriority") {
+    return jsi::Value(
+        runtime, serialize(SchedulerPriority::UserBlockingPriority));
+  }
+
+  if (propertyName == "unstable_NormalPriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::NormalPriority));
+  }
+
+  if (propertyName == "unstable_LowPriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::LowPriority));
+  }
+
+  if (propertyName == "unstable_IdlePriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::IdlePriority));
+  }
+
+  if (propertyName == "$$typeof") {
+    return jsi::Value::undefined();
+  }
+
+  react_native_assert(false && "undefined property");
+  return jsi::Value::undefined();
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <jsi/jsi.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace facebook::react {
+
+/*
+ * Exposes RuntimeScheduler to JavaScript realm.
+ */
+class RuntimeSchedulerBinding : public jsi::HostObject {
+ public:
+  RuntimeSchedulerBinding(
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
+
+  /*
+   * Installs RuntimeSchedulerBinding into JavaScript runtime if needed.
+   * Creates and sets `RuntimeSchedulerBinding` into the global namespace.
+   * In case if the global namespace already has a `RuntimeSchedulerBinding`
+   * installed, returns that.
+   */
+  static std::shared_ptr<RuntimeSchedulerBinding> createAndInstallIfNeeded(
+      jsi::Runtime &runtime,
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
+
+  /*
+   * `jsi::HostObject` specific overloads.
+   */
+  jsi::Value get(jsi::Runtime &runtime, jsi::PropNameID const &name) override;
+
+ private:
+  std::shared_ptr<RuntimeScheduler> runtimeScheduler_;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerClock.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <chrono>
+
+namespace facebook::react {
+
+/*
+ * Represents a monotonic clock suitable for measuring intervals.
+ */
+using RuntimeSchedulerClock = std::chrono::steady_clock;
+
+using RuntimeSchedulerTimePoint = RuntimeSchedulerClock::time_point;
+using RuntimeSchedulerDuration = RuntimeSchedulerClock::duration;
+
+} // namespace facebook::react