react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/android/src/main/cpp/NativeProxy.cpp

@@ -7,8 +7,10 @@
 #include <memory>
 #include <string>
 
-#if FOR_HERMES
+#if JS_RUNTIME_HERMES
 #include <hermes/hermes.h>
+#elif JS_RUNTIME_V8
+#include <v8runtime/V8RuntimeFactory.h>
 #else
 #include <jsi/JSCRuntime.h>
 #endif
@@ -20,6 +22,13 @@
 #include "NativeProxy.h"
 #include "PlatformDepMethodsHolder.h"
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <JFabricUIManager.h>
+#include "FabricUtils.h"
+#include "NewestShadowNodesRegistry.h"
+#include "ReanimatedUIManagerBinding.h"
+#endif
+
 namespace reanimated {
 
 using namespace facebook;
@@ -30,18 +39,36 @@ NativeProxy::NativeProxy(
     jsi::Runtime *rt,
     std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
     std::shared_ptr<Scheduler> scheduler,
-    jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations)
+    jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+    ,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager
+#endif
+    )
     : javaPart_(jni::make_global(jThis)),
       runtime_(rt),
       jsCallInvoker_(jsCallInvoker),
-      scheduler_(scheduler),
-      layoutAnimations(std::move(_layoutAnimations)) {}
+      layoutAnimations(std::move(_layoutAnimations)),
+      scheduler_(scheduler)
+#ifdef RCT_NEW_ARCH_ENABLED
+      ,
+      newestShadowNodesRegistry_(std::make_shared<NewestShadowNodesRegistry>())
+#endif
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  Binding *binding = fabricUIManager->getBinding();
+  RuntimeExecutor runtimeExecutor = getRuntimeExecutorFromBinding(binding);
+  std::shared_ptr<UIManager> uiManager =
+      binding->getScheduler()->getUIManager();
+  ReanimatedUIManagerBinding::createAndInstallIfNeeded(
+      *rt, runtimeExecutor, uiManager, newestShadowNodesRegistry_);
+#endif
+}
 
 NativeProxy::~NativeProxy() {
-  runtime_->global().setProperty(
-      *runtime_,
-      jsi::PropNameID::forAscii(*runtime_, "__reanimatedModuleProxy"),
-      jsi::Value::undefined());
+  // removed temporary, new event listener mechanism need fix on the RN side
+  // reactScheduler_->removeEventListener(eventListener_);
 }
 
 jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
@@ -50,7 +77,13 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
     jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
         jsCallInvokerHolder,
     jni::alias_ref<AndroidScheduler::javaobject> androidScheduler,
-    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations) {
+    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+    ,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager
+#endif
+) {
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
   auto scheduler = androidScheduler->cthis()->getScheduler();
   scheduler->setJSCallInvoker(jsCallInvoker);
@@ -59,19 +92,43 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
       (jsi::Runtime *)jsContext,
       jsCallInvoker,
       scheduler,
-      make_global(layoutAnimations));
+      make_global(layoutAnimations)
+#ifdef RCT_NEW_ARCH_ENABLED
+          ,
+      fabricUIManager
+#endif
+      /**/);
 }
 
-void NativeProxy::installJSIBindings() {
-  auto propUpdater = [this](
-                         jsi::Runtime &rt,
-                         int viewTag,
-                         const jsi::Value &viewName,
-                         const jsi::Object &props) {
+void NativeProxy::installJSIBindings(
+#ifdef RCT_NEW_ARCH_ENABLED
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager
+#endif
+    /**/) {
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  auto updatePropsFunction = [this](
+                                 jsi::Runtime &rt,
+                                 int viewTag,
+                                 const jsi::Value &viewName,
+                                 const jsi::Object &props) {
     // viewName is for iOS only, we skip it here
     this->updateProps(rt, viewTag, props);
   };
 
+  auto measureFunction =
+      [this](int viewTag) -> std::vector<std::pair<std::string, double>> {
+    return measure(viewTag);
+  };
+
+  auto scrollToFunction =
+      [this](int viewTag, double x, double y, bool animated) -> void {
+    scrollTo(viewTag, x, y, animated);
+  };
+#endif
+
   auto getCurrentTime = [this]() {
     auto method =
         javaPart_->getClass()->getMethod<local_ref<JString>()>("getUptime");
@@ -99,6 +156,12 @@ void NativeProxy::installJSIBindings() {
     this->requestRender(std::move(wrappedOnRender));
   };
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  auto synchronouslyUpdateUIPropsFunction =
+      [this](jsi::Runtime &rt, Tag tag, const jsi::Value &props) {
+        this->synchronouslyUpdateUIProps(rt, tag, props);
+      };
+#else
   auto propObtainer = [this](
                           jsi::Runtime &rt,
                           const int viewTag,
@@ -114,15 +177,12 @@ void NativeProxy::installJSIBindings() {
     return jsi::Value(rt, jsi::String::createFromAscii(rt, str.c_str()));
   };
 
-  auto measuringFunction =
-      [this](int viewTag) -> std::vector<std::pair<std::string, double>> {
-    return measure(viewTag);
-  };
-
-  auto scrollToFunction =
-      [this](int viewTag, double x, double y, bool animated) -> void {
-    scrollTo(viewTag, x, y, animated);
+  auto configurePropsFunction = [=](jsi::Runtime &rt,
+                                    const jsi::Value &uiProps,
+                                    const jsi::Value &nativeProps) {
+    this->configureProps(rt, uiProps, nativeProps);
   };
+#endif
 
   auto registerSensorFunction =
       [this](int sensorType, int interval, std::function<void(double[])> setter)
@@ -136,31 +196,50 @@ void NativeProxy::installJSIBindings() {
   auto setGestureStateFunction = [this](int handlerTag, int newState) -> void {
     setGestureState(handlerTag, newState);
   };
-#if FOR_HERMES
+
+  auto subscribeForKeyboardEventsFunction =
+      [this](std::function<void(int, int)> keyboardEventDataUpdater) -> int {
+    return subscribeForKeyboardEvents(std::move(keyboardEventDataUpdater));
+  };
+
+  auto unsubscribeFromKeyboardEventsFunction = [this](int listenerId) -> void {
+    unsubscribeFromKeyboardEvents(listenerId);
+  };
+
+#if JS_RUNTIME_HERMES
   auto config =
       ::hermes::vm::RuntimeConfig::Builder().withEnableSampleProfiling(false);
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::hermes::makeHermesRuntime(config.build());
+#elif JS_RUNTIME_V8
+  auto config = std::make_unique<rnv8::V8RuntimeConfig>();
+  config->enableInspector = false;
+  config->appName = "reanimated";
+  std::shared_ptr<jsi::Runtime> animatedRuntime =
+      rnv8::createSharedV8Runtime(runtime_, std::move(config));
 #else
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       facebook::jsc::makeJSCRuntime();
 #endif
-  auto workletRuntimeValue = runtime_->global()
-    .getProperty(*runtime_, "ArrayBuffer")
-    .asObject(*runtime_)
-    .asFunction(*runtime_)
-    .callAsConstructor(*runtime_, {static_cast<double>(sizeof(void*))});
-  uintptr_t* workletRuntimeData = reinterpret_cast<uintptr_t*>(
-    workletRuntimeValue
-      .getObject(*runtime_)
-      .getArrayBuffer(*runtime_)
-      .data(*runtime_));
+  auto workletRuntimeValue =
+      runtime_->global()
+          .getProperty(*runtime_, "ArrayBuffer")
+          .asObject(*runtime_)
+          .asFunction(*runtime_)
+          .callAsConstructor(*runtime_, {static_cast<double>(sizeof(void *))});
+  uintptr_t *workletRuntimeData = reinterpret_cast<uintptr_t *>(
+      workletRuntimeValue.getObject(*runtime_).getArrayBuffer(*runtime_).data(
+          *runtime_));
   workletRuntimeData[0] = reinterpret_cast<uintptr_t>(animatedRuntime.get());
 
   runtime_->global().setProperty(
-      *runtime_,
-      "_WORKLET_RUNTIME",
-      workletRuntimeValue);
+      *runtime_, "_WORKLET_RUNTIME", workletRuntimeValue);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  runtime_->global().setProperty(*runtime_, "_IS_FABRIC", true);
+#else
+  runtime_->global().setProperty(*runtime_, "_IS_FABRIC", false);
+#endif
 
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
@@ -175,12 +254,6 @@ void NativeProxy::installJSIBindings() {
     this->layoutAnimations->cthis()->notifyAboutEnd(tag, (isCancelled) ? 1 : 0);
   };
 
-  auto configurePropsFunction = [=](jsi::Runtime &rt,
-                                    const jsi::Value &uiProps,
-                                    const jsi::Value &nativeProps) {
-    this->configureProps(rt, uiProps, nativeProps);
-  };
-
   std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy =
       std::make_shared<LayoutAnimationsProxy>(
           notifyAboutProgress, notifyAboutEnd);
@@ -191,26 +264,57 @@ void NativeProxy::installJSIBindings() {
 
   PlatformDepMethodsHolder platformDepMethodsHolder = {
       requestRender,
-      propUpdater,
+#ifdef RCT_NEW_ARCH_ENABLED
+      synchronouslyUpdateUIPropsFunction,
+#else
+      updatePropsFunction,
       scrollToFunction,
-      measuringFunction,
+      measureFunction,
+      configurePropsFunction,
+#endif
       getCurrentTime,
       registerSensorFunction,
       unregisterSensorFunction,
       setGestureStateFunction,
-      configurePropsFunction};
+      subscribeForKeyboardEventsFunction,
+      unsubscribeFromKeyboardEventsFunction,
+  };
 
   auto module = std::make_shared<NativeReanimatedModule>(
       jsCallInvoker_,
       scheduler_,
       animatedRuntime,
       errorHandler,
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
       propObtainer,
+#endif
       layoutAnimationsProxy,
       platformDepMethodsHolder);
 
   _nativeReanimatedModule = module;
+
   std::weak_ptr<NativeReanimatedModule> weakModule = module;
+#ifdef RCT_NEW_ARCH_ENABLED
+  this->registerEventHandler([weakModule, getCurrentTime](
+                                 std::string eventName,
+                                 std::string eventAsString) {
+    if (auto module = weakModule.lock()) {
+      // handles RCTEvents from RNGestureHandler
+
+      std::string eventJSON = eventAsString.substr(
+          13, eventAsString.length() - 15); // removes "{ NativeMap: " and " }"
+      jsi::Runtime &rt = *module->runtime;
+      jsi::Value payload =
+          jsi::valueFromDynamic(rt, folly::parseJson(eventJSON));
+      // TODO: support NaN and INF values
+      // TODO: convert event directly to jsi::Value without JSON serialization
+
+      module->handleEvent(eventName, std::move(payload), getCurrentTime());
+    }
+  });
+#else
   this->registerEventHandler(
       [weakModule, getCurrentTime](
           std::string eventName, std::string eventAsString) {
@@ -225,6 +329,23 @@ void NativeProxy::installJSIBindings() {
               *module->runtime, eventTimestampName, jsi::Value::undefined());
         }
       });
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  Binding *binding = fabricUIManager->getBinding();
+  std::shared_ptr<UIManager> uiManager =
+      binding->getScheduler()->getUIManager();
+  module->setUIManager(uiManager);
+  module->setNewestShadowNodesRegistry(newestShadowNodesRegistry_);
+  newestShadowNodesRegistry_ = nullptr;
+#endif
+  //  removed temporary, new event listener mechanism need fix on the RN side
+  //  eventListener_ = std::make_shared<EventListener>(
+  //      [module, getCurrentTime](const RawEvent &rawEvent) {
+  //        return module->handleRawEvent(rawEvent, getCurrentTime());
+  //      });
+  //  reactScheduler_ = binding->getScheduler();
+  //  reactScheduler_->addEventListener(eventListener_);
 
   runtime_->global().setProperty(
       *runtime_,
@@ -236,13 +357,20 @@ bool NativeProxy::isAnyHandlerWaitingForEvent(std::string s) {
   return _nativeReanimatedModule->isAnyHandlerWaitingForEvent(s);
 }
 
+void NativeProxy::performOperations() {
+#ifdef RCT_NEW_ARCH_ENABLED
+  _nativeReanimatedModule->performOperations();
+#endif
+}
+
 void NativeProxy::registerNatives() {
   registerHybrid(
       {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
        makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
        makeNativeMethod(
            "isAnyHandlerWaitingForEvent",
-           NativeProxy::isAnyHandlerWaitingForEvent)});
+           NativeProxy::isAnyHandlerWaitingForEvent),
+       makeNativeMethod("performOperations", NativeProxy::performOperations)});
 }
 
 void NativeProxy::requestRender(std::function<void(double)> onRender) {
@@ -265,6 +393,9 @@ void NativeProxy::registerEventHandler(
       EventHandler::newObjectCxxArgs(std::move(handler)).get());
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
 void NativeProxy::updateProps(
     jsi::Runtime &rt,
     int viewTag,
@@ -302,6 +433,27 @@ std::vector<std::pair<std::string, double>> NativeProxy::measure(int viewTag) {
 
   return result;
 }
+#endif // RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+inline jni::local_ref<ReadableMap::javaobject> castReadableMap(
+    jni::local_ref<ReadableNativeMap::javaobject> const &nativeMap) {
+  return make_local(reinterpret_cast<ReadableMap::javaobject>(nativeMap.get()));
+}
+
+void NativeProxy::synchronouslyUpdateUIProps(
+    jsi::Runtime &rt,
+    Tag tag,
+    const jsi::Value &props) {
+  static const auto method =
+      javaPart_->getClass()
+          ->getMethod<void(int, jni::local_ref<ReadableMap::javaobject>)>(
+              "synchronouslyUpdateUIProps");
+  jni::local_ref<ReadableMap::javaobject> uiProps = castReadableMap(
+      ReadableNativeMap::newObjectCxxArgs(jsi::dynamicFromValue(rt, props)));
+  method(javaPart_.get(), tag, uiProps);
+}
+#endif
 
 int NativeProxy::registerSensor(
     int sensorType,
@@ -337,12 +489,29 @@ void NativeProxy::configureProps(
                         ReadableNativeArray::javaobject)>("configureProps");
   method(
       javaPart_.get(),
-      ReadableNativeArray::newObjectCxxArgs(
-          std::move(jsi::dynamicFromValue(rt, uiProps)))
+      ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, uiProps))
           .get(),
       ReadableNativeArray::newObjectCxxArgs(
-          std::move(jsi::dynamicFromValue(rt, nativeProps)))
+          jsi::dynamicFromValue(rt, nativeProps))
+          .get());
+}
+
+int NativeProxy::subscribeForKeyboardEvents(
+    std::function<void(int, int)> keyboardEventDataUpdater) {
+  auto method = javaPart_->getClass()
+                    ->getMethod<int(KeyboardEventDataUpdater::javaobject)>(
+                        "subscribeForKeyboardEvents");
+  return method(
+      javaPart_.get(),
+      KeyboardEventDataUpdater::newObjectCxxArgs(
+          std::move(keyboardEventDataUpdater))
           .get());
 }
 
+void NativeProxy::unsubscribeFromKeyboardEvents(int listenerId) {
+  auto method = javaPart_->getClass()->getMethod<void(int)>(
+      "unsubscribeFromKeyboardEvents");
+  method(javaPart_.get(), listenerId);
+}
+
 } // namespace reanimated

package/android/src/main/cpp/OnLoad.cpp

@@ -13,5 +13,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
     reanimated::AndroidScheduler::registerNatives();
     reanimated::LayoutAnimations::registerNatives();
     reanimated::SensorSetter::registerNatives();
+    reanimated::KeyboardEventDataUpdater::registerNatives();
   });
 }

package/android/src/main/cpp/headers/NativeProxy.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <JFabricUIManager.h>
+#endif
+
 #include <ReactCommon/CallInvokerHolder.h>
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
@@ -118,6 +122,32 @@ class SensorSetter : public HybridClass<SensorSetter> {
   std::function<void(double[])> callback_;
 };
 
+class KeyboardEventDataUpdater : public HybridClass<KeyboardEventDataUpdater> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy$KeyboardEventDataUpdater;";
+
+  void keyboardEventDataUpdater(int keyboardState, int height) {
+    callback_(keyboardState, height);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod(
+            "keyboardEventDataUpdater",
+            KeyboardEventDataUpdater::keyboardEventDataUpdater),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit KeyboardEventDataUpdater(std::function<void(int, int)> callback)
+      : callback_(std::move(callback)) {}
+
+  std::function<void(int, int)> callback_;
+};
+
 class NativeProxy : public jni::HybridClass<NativeProxy> {
  public:
   static auto constexpr kJavaDescriptor =
@@ -128,7 +158,13 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
       jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
           jsCallInvokerHolder,
       jni::alias_ref<AndroidScheduler::javaobject> scheduler,
-      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations);
+      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+      ,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager
+#endif
+      /**/);
   static void registerNatives();
 
   ~NativeProxy();
@@ -139,18 +175,31 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
   jsi::Runtime *runtime_;
   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
   std::shared_ptr<NativeReanimatedModule> _nativeReanimatedModule;
-  std::shared_ptr<Scheduler> scheduler_;
   jni::global_ref<LayoutAnimations::javaobject> layoutAnimations;
-
+  std::shared_ptr<Scheduler> scheduler_;
+#ifdef RCT_NEW_ARCH_ENABLED
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+
+// removed temporary, new event listener mechanism need fix on the RN side
+// std::shared_ptr<facebook::react::Scheduler> reactScheduler_;
+// std::shared_ptr<EventListener> eventListener_;
+#endif
+#ifdef RCT_NEW_ARCH_ENABLED
+  void installJSIBindings(
+      jni::alias_ref<JFabricUIManager::javaobject> fabricUIManager);
+  void synchronouslyUpdateUIProps(
+      jsi::Runtime &rt,
+      Tag viewTag,
+      const jsi::Value &uiProps);
+#else
   void installJSIBindings();
+#endif
   bool isAnyHandlerWaitingForEvent(std::string);
+  void performOperations();
   void requestRender(std::function<void(double)> onRender);
   void registerEventHandler(
       std::function<void(std::string, std::string)> handler);
-  void updateProps(jsi::Runtime &rt, int viewTag, const jsi::Object &props);
-  void scrollTo(int viewTag, double x, double y, bool animated);
   void setGestureState(int handlerTag, int newState);
-  std::vector<std::pair<std::string, double>> measure(int viewTag);
   int registerSensor(
       int sensorType,
       int interval,
@@ -160,13 +209,29 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps);
+  int subscribeForKeyboardEvents(
+      std::function<void(int, int)> keyboardEventDataUpdater);
+  void unsubscribeFromKeyboardEvents(int listenerId);
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  void updateProps(jsi::Runtime &rt, int viewTag, const jsi::Object &props);
+  void scrollTo(int viewTag, double x, double y, bool animated);
+  std::vector<std::pair<std::string, double>> measure(int viewTag);
+#endif
 
   explicit NativeProxy(
       jni::alias_ref<NativeProxy::jhybridobject> jThis,
       jsi::Runtime *rt,
       std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
       std::shared_ptr<Scheduler> scheduler,
-      jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations);
+      jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+      ,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager
+#endif
+      /**/);
 };
 
 } // namespace reanimated