react-native-tvos 0.71.13-1 → 0.72.4-0

package/ReactCommon/react/renderer/runtimescheduler/React-runtimescheduler.podspec

@@ -0,0 +1,66 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+folly_version = '2021.07.22.00'
+
+header_search_paths = [
+    "\"$(PODS_ROOT)/RCT-Folly\"",
+]
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/../../..\"" #this is needed to allow the RuntimeScheduler access its own files
+  header_search_paths << "\"${PODS_CONFIGURATION_BUILD_DIR}/React-debug/React_debug.framework/Headers\""
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-runtimescheduler"
+  s.version                = version
+  s.summary                = "-"  # TODO
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = { :ios => min_ios_version_supported, :tvos => min_ios_version_supported }
+  s.source                 = source
+  s.source_files           = "**/*.{cpp,h}"
+  s.compiler_flags         = folly_compiler_flags
+  s.header_dir             = "react/renderer/runtimescheduler"
+  s.exclude_files          = "tests"
+  s.pod_target_xcconfig    = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+    "HEADER_SEARCH_PATHS" => header_search_paths.join(' ')}
+
+  if ENV['USE_FRAMEWORKS']
+    s.module_name            = "React_runtimescheduler"
+    s.header_mappings_dir  = File.absolute_path("../../..")
+  end
+
+  s.dependency "React-jsi"
+  s.dependency "React-runtimeexecutor"
+  s.dependency "React-callinvoker"
+  s.dependency "React-debug"
+  s.dependency "glog"
+  s.dependency "RCT-Folly", folly_version
+
+  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
+    s.dependency "hermes-engine"
+  else
+    s.dependency "React-jsi"
+  end
+
+end

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

@@ -6,6 +6,7 @@
  */
 
 #include "RuntimeScheduler.h"
+#include "SchedulerPriorityUtils.h"
 
 #include <utility>
 #include "ErrorUtils.h"
@@ -19,8 +20,7 @@ RuntimeScheduler::RuntimeScheduler(
     std::function<RuntimeSchedulerTimePoint()> now)
     : runtimeExecutor_(std::move(runtimeExecutor)), now_(std::move(now)) {}
 
-void RuntimeScheduler::scheduleWork(
-    std::function<void(jsi::Runtime &)> callback) const {
+void RuntimeScheduler::scheduleWork(RawCallback callback) const {
   runtimeAccessRequests_ += 1;
 
   runtimeExecutor_(
@@ -34,7 +34,20 @@ void RuntimeScheduler::scheduleWork(
 std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
     SchedulerPriority priority,
     jsi::Function callback) {
-  auto expirationTime = now() + timeoutForSchedulerPriority(priority);
+  auto expirationTime = now_() + timeoutForSchedulerPriority(priority);
+  auto task =
+      std::make_shared<Task>(priority, std::move(callback), expirationTime);
+  taskQueue_.push(task);
+
+  scheduleWorkLoopIfNecessary();
+
+  return task;
+}
+
+std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
+    SchedulerPriority priority,
+    RawCallback callback) {
+  auto expirationTime = now_() + timeoutForSchedulerPriority(priority);
   auto task =
       std::make_shared<Task>(priority, std::move(callback), expirationTime);
   taskQueue_.push(task);
@@ -64,8 +77,7 @@ RuntimeSchedulerTimePoint RuntimeScheduler::now() const noexcept {
   return now_();
 }
 
-void RuntimeScheduler::executeNowOnTheSameThread(
-    std::function<void(jsi::Runtime &runtime)> callback) {
+void RuntimeScheduler::executeNowOnTheSameThread(RawCallback callback) {
   runtimeAccessRequests_ += 1;
   executeSynchronouslyOnSameThread_CAN_DEADLOCK(
       runtimeExecutor_,

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

@@ -35,7 +35,7 @@ class RuntimeScheduler final {
   RuntimeScheduler(RuntimeScheduler &&) = delete;
   RuntimeScheduler &operator=(RuntimeScheduler &&) = delete;
 
-  void scheduleWork(std::function<void(jsi::Runtime &)> callback) const;
+  void scheduleWork(RawCallback callback) const;
 
   /*
    * Grants access to the runtime synchronously on the caller's thread.
@@ -44,8 +44,7 @@ class RuntimeScheduler final {
    * by dispatching a synchronous event via event emitter in your native
    * component.
    */
-  void executeNowOnTheSameThread(
-      std::function<void(jsi::Runtime &runtime)> callback);
+  void executeNowOnTheSameThread(RawCallback callback);
 
   /*
    * Adds a JavaScript callback to priority queue with given priority.
@@ -57,6 +56,10 @@ class RuntimeScheduler final {
       SchedulerPriority priority,
       jsi::Function callback);
 
+  std::shared_ptr<Task> scheduleTask(
+      SchedulerPriority priority,
+      RawCallback callback);
+
   /*
    * Cancelled task will never be executed.
    *

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

@@ -6,10 +6,11 @@
  */
 
 #include "RuntimeSchedulerBinding.h"
-#include "SchedulerPriority.h"
+#include <ReactCommon/SchedulerPriority.h>
+#include "RuntimeScheduler.h"
+#include "SchedulerPriorityUtils.h"
 #include "primitives.h"
 
-#include <react/debug/react_native_assert.h>
 #include <chrono>
 #include <memory>
 #include <utility>
@@ -78,7 +79,7 @@ jsi::Value RuntimeSchedulerBinding::get(
             jsi::Runtime &runtime,
             jsi::Value const &,
             jsi::Value const *arguments,
-            size_t) noexcept -> jsi::Value {
+            size_t count) noexcept -> jsi::Value {
           SchedulerPriority priority = fromRawValue(arguments[0].getNumber());
           auto callback = arguments[1].getObject(runtime).getFunction(runtime);
 
@@ -151,7 +152,7 @@ jsi::Value RuntimeSchedulerBinding::get(
         });
   }
 
-  // TODO: remmove this, as it's deprecated in the JS scheduler
+  // TODO: remove this, as it's deprecated in the JS scheduler
   if (propertyName == "unstable_getCurrentPriorityLevel") {
     return jsi::Function::createFromHostFunction(
         runtime,

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

@@ -8,11 +8,12 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 
 namespace facebook {
 namespace react {
 
+class RuntimeScheduler;
+
 /*
  * Exposes RuntimeScheduler to JavaScript realm.
  */

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

@@ -8,6 +8,7 @@
 #include "RuntimeSchedulerCallInvoker.h"
 
 #include <utility>
+#include "RuntimeScheduler.h"
 
 namespace facebook::react {
 
@@ -15,18 +16,27 @@ RuntimeSchedulerCallInvoker::RuntimeSchedulerCallInvoker(
     std::weak_ptr<RuntimeScheduler> runtimeScheduler)
     : runtimeScheduler_(std::move(runtimeScheduler)) {}
 
-void RuntimeSchedulerCallInvoker::invokeAsync(std::function<void()> &&func) {
+void RuntimeSchedulerCallInvoker::invokeAsync(CallFunc &&func) {
   if (auto runtimeScheduler = runtimeScheduler_.lock()) {
     runtimeScheduler->scheduleWork(
         [func = std::move(func)](jsi::Runtime &) { func(); });
   }
 }
 
-void RuntimeSchedulerCallInvoker::invokeSync(std::function<void()> &&func) {
+void RuntimeSchedulerCallInvoker::invokeSync(CallFunc &&func) {
   if (auto runtimeScheduler = runtimeScheduler_.lock()) {
     runtimeScheduler->executeNowOnTheSameThread(
         [func = std::move(func)](jsi::Runtime &) { func(); });
   }
 }
 
+void RuntimeSchedulerCallInvoker::invokeAsync(
+    SchedulerPriority priority,
+    CallFunc &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->scheduleTask(
+        priority, [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
 } // namespace facebook::react

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

@@ -8,21 +8,23 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
-#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 
 namespace facebook {
 namespace react {
 
+class RuntimeScheduler;
+
 /*
- * Exposes RuntimeScheduler to native modules. All calls invonked on JavaScript
+ * Exposes RuntimeScheduler to native modules. All calls invoked on JavaScript
  * queue from native modules will be funneled through RuntimeScheduler.
  */
 class RuntimeSchedulerCallInvoker : public CallInvoker {
  public:
   RuntimeSchedulerCallInvoker(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
 
-  void invokeAsync(std::function<void()> &&func) override;
-  void invokeSync(std::function<void()> &&func) override;
+  void invokeAsync(CallFunc &&func) override;
+  void invokeSync(CallFunc &&func) override;
+  void invokeAsync(SchedulerPriority priority, CallFunc &&func) override;
 
  private:
   /*

package/ReactCommon/react/renderer/runtimescheduler/{SchedulerPriority.h → SchedulerPriorityUtils.h}

@@ -7,19 +7,11 @@
 
 #pragma once
 
+#include <ReactCommon/SchedulerPriority.h>
 #include <react/debug/react_native_assert.h>
 #include <chrono>
 
-namespace facebook {
-namespace react {
-
-enum class SchedulerPriority : int {
-  ImmediatePriority = 1,
-  UserBlockingPriority = 2,
-  NormalPriority = 3,
-  LowPriority = 4,
-  IdlePriority = 5,
-};
+namespace facebook::react {
 
 static constexpr std::underlying_type<SchedulerPriority>::type serialize(
     SchedulerPriority schedulerPriority) {
@@ -61,21 +53,4 @@ static inline std::chrono::milliseconds timeoutForSchedulerPriority(
   }
 }
 
-static inline std::string debugValueForSchedulerPriority(
-    SchedulerPriority schedulerPriority) {
-  switch (schedulerPriority) {
-    case SchedulerPriority::ImmediatePriority:
-      return "SchedulerPriority::ImmediatePriority";
-    case SchedulerPriority::UserBlockingPriority:
-      return "SchedulerPriority::UserBlockingPriority";
-    case SchedulerPriority::NormalPriority:
-      return "SchedulerPriority::NormalPriority";
-    case SchedulerPriority::LowPriority:
-      return "SchedulerPriority::LowPriority";
-    case SchedulerPriority::IdlePriority:
-      return "SchedulerPriority::IdlePriority";
-  }
-}
-
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

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

@@ -17,18 +17,35 @@ Task::Task(
       callback(std::move(callback)),
       expirationTime(expirationTime) {}
 
+Task::Task(
+    SchedulerPriority priority,
+    RawCallback callback,
+    std::chrono::steady_clock::time_point expirationTime)
+    : priority(priority),
+      callback(std::move(callback)),
+      expirationTime(expirationTime) {}
+
 jsi::Value Task::execute(jsi::Runtime &runtime, bool didUserCallbackTimeout) {
   auto result = jsi::Value::undefined();
-  // Cancelled task doesn't have a callback.
-  if (callback) {
+  // Canceled task doesn't have a callback.
+  if (!callback) {
+    return result;
+  }
+
+  auto &cbVal = callback.value();
+
+  if (cbVal.index() == 0) {
     // Callback in JavaScript is expecting a single bool parameter.
     // React team plans to remove it in the future when a scheduler bug on web
     // is resolved.
-    result = callback.value().call(runtime, {didUserCallbackTimeout});
-
-    // Destroying callback to prevent calling it twice.
-    callback.reset();
+    result =
+        std::get<jsi::Function>(cbVal).call(runtime, {didUserCallbackTimeout});
+  } else {
+    // Calling a raw callback
+    std::get<RawCallback>(cbVal)(runtime);
   }
+  // Destroying callback to prevent calling it twice.
+  callback.reset();
   return result;
 }
 

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

@@ -7,30 +7,37 @@
 
 #pragma once
 
+#include <ReactCommon/SchedulerPriority.h>
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
-#include <react/renderer/runtimescheduler/SchedulerPriority.h>
 
 #include <optional>
+#include <variant>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class RuntimeScheduler;
 class TaskPriorityComparer;
 
-struct Task final {
+using RawCallback = std::function<void(jsi::Runtime &)>;
+
+struct Task final : public jsi::NativeState {
   Task(
       SchedulerPriority priority,
       jsi::Function callback,
       std::chrono::steady_clock::time_point expirationTime);
 
+  Task(
+      SchedulerPriority priority,
+      RawCallback callback,
+      std::chrono::steady_clock::time_point expirationTime);
+
  private:
   friend RuntimeScheduler;
   friend TaskPriorityComparer;
 
   SchedulerPriority priority;
-  std::optional<jsi::Function> callback;
+  std::optional<std::variant<jsi::Function, RawCallback>> callback;
   RuntimeSchedulerClock::time_point expirationTime;
 
   jsi::Value execute(jsi::Runtime &runtime, bool didUserCallbackTimeout);
@@ -45,5 +52,4 @@ class TaskPriorityComparer {
   }
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/Task.h>
 
@@ -22,7 +21,7 @@ struct TaskWrapper : public jsi::HostObject {
 
 inline static jsi::Value valueFromTask(
     jsi::Runtime &runtime,
-    std::shared_ptr<Task> const &task) {
+    std::shared_ptr<Task> task) {
   return jsi::Object::createFromHostObject(
       runtime, std::make_shared<TaskWrapper>(task));
 }

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -6,7 +6,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <hermes/API/hermes/hermes.h>
+#include <hermes/hermes.h>
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <memory>

package/ReactCommon/react/renderer/runtimescheduler/tests/SchedulerPriorityTest.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <react/renderer/runtimescheduler/SchedulerPriorityUtils.h>
 #include <react/renderer/runtimescheduler/Task.h>
 #include <chrono>
 

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -118,18 +118,26 @@ Scheduler::Scheduler(
     uiManager->registerCommitHook(*commitHook);
   }
 
-  if (animationDelegate != nullptr) {
-    animationDelegate->setComponentDescriptorRegistry(
-        componentDescriptorRegistry_);
-  }
-  uiManager_->setAnimationDelegate(animationDelegate);
-
 #ifdef ANDROID
   removeOutstandingSurfacesOnDestruction_ = true;
+  reduceDeleteCreateMutationLayoutAnimation_ = reactNativeConfig_->getBool(
+      "react_fabric:reduce_delete_create_mutation_layout_animation_android");
 #else
   removeOutstandingSurfacesOnDestruction_ = reactNativeConfig_->getBool(
       "react_fabric:remove_outstanding_surfaces_on_destruction_ios");
+  reduceDeleteCreateMutationLayoutAnimation_ = true;
 #endif
+
+  CoreFeatures::blockPaintForUseLayoutEffect = reactNativeConfig_->getBool(
+      "react_fabric:block_paint_for_use_layout_effect");
+
+  if (animationDelegate != nullptr) {
+    animationDelegate->setComponentDescriptorRegistry(
+        componentDescriptorRegistry_);
+    animationDelegate->setReduceDeleteCreateMutation(
+        reduceDeleteCreateMutationLayoutAnimation_);
+  }
+  uiManager_->setAnimationDelegate(animationDelegate);
 }
 
 Scheduler::~Scheduler() {
@@ -151,7 +159,7 @@ Scheduler::~Scheduler() {
   // Then, let's verify that the requirement was satisfied.
   auto surfaceIds = std::vector<SurfaceId>{};
   uiManager_->getShadowTreeRegistry().enumerate(
-      [&surfaceIds](ShadowTree const &shadowTree) {
+      [&surfaceIds](ShadowTree const &shadowTree, bool &) {
         surfaceIds.push_back(shadowTree.getSurfaceId());
       });
 
@@ -259,7 +267,8 @@ void Scheduler::renderTemplateToSurface(
                         std::make_shared<ShadowNode::ListOfShared>(
                             ShadowNode::ListOfShared{tree}),
                     });
-              });
+              },
+              {/* default commit options */});
         });
   } catch (const std::exception &e) {
     LOG(ERROR) << "    >>>> EXCEPTION <<<  rendering uiTemplate in "
@@ -293,11 +302,34 @@ void Scheduler::animationTick() const {
 #pragma mark - UIManagerDelegate
 
 void Scheduler::uiManagerDidFinishTransaction(
-    MountingCoordinator::Shared const &mountingCoordinator) {
+    MountingCoordinator::Shared mountingCoordinator,
+    bool mountSynchronously) {
   SystraceSection s("Scheduler::uiManagerDidFinishTransaction");
 
   if (delegate_ != nullptr) {
-    delegate_->schedulerDidFinishTransaction(mountingCoordinator);
+    if (CoreFeatures::blockPaintForUseLayoutEffect) {
+      auto weakRuntimeScheduler =
+          contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
+              "RuntimeScheduler");
+      auto runtimeScheduler = weakRuntimeScheduler.has_value()
+          ? weakRuntimeScheduler.value().lock()
+          : nullptr;
+      if (runtimeScheduler && !mountSynchronously) {
+        runtimeScheduler->scheduleTask(
+            SchedulerPriority::UserBlockingPriority,
+            [delegate = delegate_,
+             mountingCoordinator =
+                 std::move(mountingCoordinator)](jsi::Runtime &) {
+              delegate->schedulerDidFinishTransaction(
+                  std::move(mountingCoordinator));
+            });
+      } else {
+        delegate_->schedulerDidFinishTransaction(
+            std::move(mountingCoordinator));
+      }
+    } else {
+      delegate_->schedulerDidFinishTransaction(std::move(mountingCoordinator));
+    }
   }
 }
 void Scheduler::uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) {

package/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -88,7 +88,8 @@ class Scheduler final : public UIManagerDelegate {
 #pragma mark - UIManagerDelegate
 
   void uiManagerDidFinishTransaction(
-      MountingCoordinator::Shared const &mountingCoordinator) override;
+      MountingCoordinator::Shared mountingCoordinator,
+      bool mountSynchronously) override;
   void uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) override;
   void uiManagerDidDispatchCommand(
       const ShadowNode::Shared &shadowNode,
@@ -143,6 +144,7 @@ class Scheduler final : public UIManagerDelegate {
    * Temporary flags.
    */
   bool removeOutstandingSurfacesOnDestruction_{false};
+  bool reduceDeleteCreateMutationLayoutAnimation_{false};
 };
 
 } // namespace react

package/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -13,8 +13,7 @@
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowView.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 /*
  * Abstract class for Scheduler's delegate.
@@ -27,7 +26,7 @@ class SchedulerDelegate {
    * to construct a new one.
    */
   virtual void schedulerDidFinishTransaction(
-      MountingCoordinator::Shared const &mountingCoordinator) = 0;
+      MountingCoordinator::Shared mountingCoordinator) = 0;
 
   /*
    * Called right after a new ShadowNode was created.
@@ -56,5 +55,4 @@ class SchedulerDelegate {
   virtual ~SchedulerDelegate() noexcept = default;
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/renderer/scheduler/SchedulerToolbox.h

@@ -13,7 +13,7 @@
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/EventBeat.h>
 #include <react/renderer/leakchecker/LeakChecker.h>
-#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
 #include <react/renderer/uimanager/UIManagerCommitHook.h>
 #include <react/renderer/uimanager/primitives.h>
 #include <react/utils/ContextContainer.h>