feat: Bridgeless with runtimeExecutor

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -44,6 +44,7 @@ bool CoreFeatures::useNativeState;
 
 namespace reanimated {
 
+// With `jsInvoker`.
 NativeReanimatedModule::NativeReanimatedModule(
     jsi::Runtime &rnRuntime,
     const std::shared_ptr<CallInvoker> &jsInvoker,
@@ -86,7 +87,61 @@ NativeReanimatedModule::NativeReanimatedModule(
           platformDepMethodsHolder.subscribeForKeyboardEvents),
       unsubscribeFromKeyboardEventsFunction_(
           platformDepMethodsHolder.unsubscribeFromKeyboardEvents),
-      isBridgeless_(jsInvoker == nullptr) {
+      isBridgeless_(false) {
+  commonInit(platformDepMethodsHolder);
+}
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+// With `runtimeExecutor`.
+NativeReanimatedModule::NativeReanimatedModule(
+    jsi::Runtime &rnRuntime,
+    RuntimeExecutor runtimeExecutor,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    const PlatformDepMethodsHolder &platformDepMethodsHolder,
+    const std::string &valueUnpackerCode)
+    : NativeReanimatedModuleSpec(nullptr),
+      jsQueue_(jsQueue),
+      jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, runtimeExecutor)),
+      uiScheduler_(uiScheduler),
+      uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
+          rnRuntime,
+          jsQueue,
+          jsScheduler_,
+          "Reanimated UI runtime",
+          true /* supportsLocking */,
+          valueUnpackerCode)),
+      valueUnpackerCode_(valueUnpackerCode),
+      eventHandlerRegistry_(std::make_unique<EventHandlerRegistry>()),
+      requestRender_(platformDepMethodsHolder.requestRender),
+      onRenderCallback_([this](const double timestampMs) {
+        renderRequested_ = false;
+        onRender(timestampMs);
+      }),
+      animatedSensorModule_(platformDepMethodsHolder),
+      jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
+      layoutAnimationsManager_(jsLogger_),
+#ifdef RCT_NEW_ARCH_ENABLED
+      synchronouslyUpdateUIPropsFunction_(
+          platformDepMethodsHolder.synchronouslyUpdateUIPropsFunction),
+      propsRegistry_(std::make_shared<PropsRegistry>()),
+#else
+      obtainPropFunction_(platformDepMethodsHolder.obtainPropFunction),
+      configurePropsPlatformFunction_(
+          platformDepMethodsHolder.configurePropsFunction),
+      updatePropsFunction_(platformDepMethodsHolder.updatePropsFunction),
+#endif
+      subscribeForKeyboardEventsFunction_(
+          platformDepMethodsHolder.subscribeForKeyboardEvents),
+      unsubscribeFromKeyboardEventsFunction_(
+          platformDepMethodsHolder.unsubscribeFromKeyboardEvents),
+      isBridgeless_(true) {
+  commonInit(platformDepMethodsHolder);
+}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+
+void NativeReanimatedModule::commonInit(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder) {
   auto requestAnimationFrame =
       [this](jsi::Runtime &rt, const jsi::Value &callback) {
         this->requestAnimationFrame(rt, callback);

Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -31,6 +31,7 @@ namespace reanimated {
 
 class NativeReanimatedModule : public NativeReanimatedModuleSpec {
  public:
+  // With `jsInvoker`.
   NativeReanimatedModule(
       jsi::Runtime &rnRuntime,
       const std::shared_ptr<CallInvoker> &jsInvoker,
@@ -39,6 +40,17 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec {
       const PlatformDepMethodsHolder &platformDepMethodsHolder,
       const std::string &valueUnpackerCode);
 
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  // With `runtimeExecutor`.
+  NativeReanimatedModule(
+      jsi::Runtime &rnRuntime,
+      RuntimeExecutor runtimeExecutor,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const PlatformDepMethodsHolder &platformDepMethodsHolder,
+      const std::string &valueUnpackerCode);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
   ~NativeReanimatedModule();
 
   jsi::Value makeShareableClone(
@@ -172,6 +184,8 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec {
   }
 
  private:
+  void commonInit(const PlatformDepMethodsHolder &platformDepMethodsHolder);
+
   void requestAnimationFrame(jsi::Runtime &rt, const jsi::Value &callback);
 
 #ifdef RCT_NEW_ARCH_ENABLED

Common/cpp/ReanimatedRuntime/WorkletRuntimeDecorator.cpp

@@ -62,7 +62,7 @@ void WorkletRuntimeDecorator::decorate(
           jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
           1,
           evalWithSourceUrl));
-#endif
+#endif // NDEBUG
 
   jsi_utils::installJsiFunction(
       rt, "_toString", [](jsi::Runtime &rt, const jsi::Value &value) {

Common/cpp/Tools/JSScheduler.cpp

@@ -1,12 +1,30 @@
 #include "JSScheduler.h"
 
-#include <utility>
+using namespace facebook;
+using namespace react;
 
 namespace reanimated {
+JSScheduler::JSScheduler(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<CallInvoker> &jsCallInvoker)
+    : rnRuntime_(rnRuntime),
+      jsCallInvoker_(jsCallInvoker),
+      scheduleOnJS([&](Job job) {
+        jsCallInvoker_->invokeAsync(
+            [job = std::move(job), &rt = rnRuntime_] { job(rt); });
+      }) {}
 
-void JSScheduler::scheduleOnJS(std::function<void(jsi::Runtime &rt)> job) {
-  jsCallInvoker_->invokeAsync(
-      [job = std::move(job), &rt = rnRuntime_] { job(rt); });
-}
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+// With `runtimeExecutor`.
+JSScheduler::JSScheduler(
+    jsi::Runtime &rnRuntime,
+    RuntimeExecutor runtimeExecutor)
+    : rnRuntime_(rnRuntime),
+      runtimeExecutor_(runtimeExecutor),
+      scheduleOnJS([&](Job job) {
+        runtimeExecutor_(
+            [job = std::move(job)](jsi::Runtime &runtime) { job(runtime); });
+      }) {}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
 
 } // namespace reanimated

Common/cpp/Tools/JSScheduler.h

@@ -1,25 +1,42 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/RuntimeExecutor.h>
 #include <jsi/jsi.h>
 
 #include <memory>
+#include <utility>
 
 using namespace facebook;
+using namespace react;
+
+using Job = std::function<void(jsi::Runtime &rt)>;
 
 namespace reanimated {
 
 class JSScheduler {
  public:
+  // With `jsCallInvoker`.
+  explicit JSScheduler(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker);
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  // With `runtimeExecutor`.
   explicit JSScheduler(
       jsi::Runtime &rnRuntime,
-      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
-      : rnRuntime_(rnRuntime), jsCallInvoker_(jsCallInvoker) {}
-  void scheduleOnJS(std::function<void(jsi::Runtime &rt)> job);
+      RuntimeExecutor runtimeExecutor);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
 
  protected:
   jsi::Runtime &rnRuntime_;
-  const std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
+  const std::shared_ptr<CallInvoker> jsCallInvoker_ = nullptr;
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  RuntimeExecutor runtimeExecutor_ = nullptr;
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
+ public:
+  const std::function<void(Job)> scheduleOnJS = nullptr;
 };
 
 } // namespace reanimated

FabricExample/android/app/src/main/java/com/fabricexample/MainApplication.kt

@@ -37,7 +37,7 @@ class MainApplication : Application(), ReactApplication {
     SoLoader.init(this, false)
     if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
       // If you opted-in for the New Architecture, we load the native entry point for this app.
-      load(bridgelessEnabled = false)
+      load(bridgelessEnabled = true)
     }
   }
 }

FabricExample/ios/FabricExample/AppDelegate.mm

@@ -30,7 +30,7 @@ - (NSURL *)bundleURL
 
 - (BOOL)bridgelessEnabled
 {
-  return NO;
+  return YES;
 }
 
 @end

android/build.gradle

@@ -388,6 +388,16 @@ android {
                     srcDirs += "src/reactNativeVersionPatch/ReactFeatureFlagsWrapper/latest"
                 }
             }
+
+            // RuntimeExecutor
+            if (IS_NEW_ARCHITECTURE_ENABLED) {
+                if (REACT_NATIVE_MINOR_VERSION <= 73) {
+                    srcDirs += "src/reactNativeVersionPatch/RuntimeExecutor/73"
+                } else {
+                    srcDirs += "src/reactNativeVersionPatch/RuntimeExecutor/latest"
+                }
+            }
+
         }
     }
 }

android/src/main/cpp/NativeProxy.cpp

@@ -51,6 +51,40 @@ NativeProxy::NativeProxy(
           valueUnpackerCode)),
       layoutAnimations_(std::move(layoutAnimations)) {
 #ifdef RCT_NEW_ARCH_ENABLED
+  commonInit(fabricUIManager);
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+NativeProxy::NativeProxy(
+    jni::alias_ref<NativeProxy::javaobject> jThis,
+    jsi::Runtime *rnRuntime,
+    RuntimeExecutor runtimeExecutor,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    jni::global_ref<LayoutAnimations::javaobject> layoutAnimations,
+    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager,
+
+    const std::string &valueUnpackerCode)
+    : javaPart_(jni::make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      nativeReanimatedModule_(std::make_shared<NativeReanimatedModule>(
+          *rnRuntime,
+          runtimeExecutor,
+          std::make_shared<JMessageQueueThread>(messageQueueThread),
+          uiScheduler,
+          getPlatformDependentMethods(),
+          valueUnpackerCode)),
+      layoutAnimations_(std::move(layoutAnimations)) {
+  commonInit(fabricUIManager);
+}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+void NativeProxy::commonInit(
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        &fabricUIManager) {
   const auto &uiManager =
       fabricUIManager->getBinding()->getScheduler()->getUIManager();
   nativeReanimatedModule_->initializeFabric(uiManager);
@@ -63,8 +97,8 @@ NativeProxy::NativeProxy(
   //     });
   // reactScheduler_ = binding->getScheduler();
   // reactScheduler_->addEventListener(eventListener_);
-#endif
 }
+#endif // RCT_NEW_ARCH_ENABLED
 
 NativeProxy::~NativeProxy() {
   // removed temporary, new event listener mechanism need fix on the RN side
@@ -104,6 +138,31 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
       valueUnpackerCode);
 }
 
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybridBridgeless(
+    jni::alias_ref<jhybridobject> jThis,
+    jlong jsContext,
+    jni::alias_ref<react::JRuntimeExecutor::javaobject> runtimeExecutorHolder,
+    jni::alias_ref<AndroidUIScheduler::javaobject> androidUiScheduler,
+    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations,
+    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager,
+    const std::string &valueUnpackerCode) {
+  auto uiScheduler = androidUiScheduler->cthis()->getUIScheduler();
+  auto runtimeExecutor = runtimeExecutorHolder->cthis()->get();
+  return makeCxxInstance(
+      jThis,
+      (jsi::Runtime *)jsContext,
+      runtimeExecutor,
+      uiScheduler,
+      make_global(layoutAnimations),
+      messageQueueThread,
+      fabricUIManager,
+      valueUnpackerCode);
+}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
 #ifndef NDEBUG
 void NativeProxy::checkJavaVersion(jsi::Runtime &rnRuntime) {
   std::string javaVersion;
@@ -177,13 +236,18 @@ bool NativeProxy::getIsReducedMotion() {
 }
 
 void NativeProxy::registerNatives() {
-  registerHybrid(
-      {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
-       makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
-       makeNativeMethod(
-           "isAnyHandlerWaitingForEvent",
-           NativeProxy::isAnyHandlerWaitingForEvent),
-       makeNativeMethod("performOperations", NativeProxy::performOperations)});
+  registerHybrid({
+    makeNativeMethod("initHybrid", NativeProxy::initHybrid),
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+        makeNativeMethod(
+            "initHybridBridgeless", NativeProxy::initHybridBridgeless),
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+        makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
+        makeNativeMethod(
+            "isAnyHandlerWaitingForEvent",
+            NativeProxy::isAnyHandlerWaitingForEvent),
+        makeNativeMethod("performOperations", NativeProxy::performOperations)
+  });
 }
 
 void NativeProxy::requestRender(

android/src/main/cpp/NativeProxy.h

@@ -3,6 +3,9 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #include <react/fabric/JFabricUIManager.h>
 #include <react/renderer/scheduler/Scheduler.h>
+#if REACT_NATIVE_MINOR_VERSION >= 74
+#include <react/jni/JRuntimeExecutor.h>
+#endif // REACT_NATIVE_MINOR_VERSION >= 74
 #endif
 
 #include <ReactCommon/CallInvokerHolder.h>
@@ -158,6 +161,19 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
           fabricUIManager,
 #endif
       const std::string &valueUnpackerCode);
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  static jni::local_ref<jhybriddata> initHybridBridgeless(
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      jni::alias_ref<react::JRuntimeExecutor::javaobject> runtimeExecutorHolder,
+      jni::alias_ref<AndroidUIScheduler::javaobject> androidUiScheduler,
+      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations,
+      jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager,
+      const std::string &valueUnpackerCode);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
   static void registerNatives();
 
   ~NativeProxy();
@@ -269,6 +285,24 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
           fabricUIManager,
 #endif
       const std::string &valueUnpackerCode);
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  explicit NativeProxy(
+      jni::alias_ref<NativeProxy::jhybridobject> jThis,
+      jsi::Runtime *rnRuntime,
+      RuntimeExecutor runtimeExecutor,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      jni::global_ref<LayoutAnimations::javaobject> layoutAnimations,
+      jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager,
+      const std::string &valueUnpackerCode);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  void commonInit(jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+                      &fabricUIManager);
+#endif // RCT_NEW_ARCH_ENABLED
 };
 
 } // namespace reanimated