react-native-reanimated 3.0.2 → 3.1.0

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

@@ -44,7 +44,7 @@ NativeProxy::NativeProxy(
     : javaPart_(jni::make_global(jThis)),
       runtime_(rt),
       jsCallInvoker_(jsCallInvoker),
-      layoutAnimations(std::move(_layoutAnimations)),
+      layoutAnimations_(std::move(_layoutAnimations)),
       scheduler_(scheduler)
 #ifdef RCT_NEW_ARCH_ENABLED
       ,
@@ -68,7 +68,7 @@ NativeProxy::~NativeProxy() {
   // cleanup all animated sensors here, since NativeProxy
   // has already been destroyed when AnimatedSensorModule's
   // destructor is ran
-  _nativeReanimatedModule->cleanupSensors();
+  nativeReanimatedModule_->cleanupSensors();
 }
 
 jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
@@ -108,158 +108,12 @@ void NativeProxy::installJSIBindings(
         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]() {
-    static const auto method =
-        javaPart_->getClass()->getMethod<jlong()>("getCurrentTime");
-    jlong output = method(javaPart_.get());
-    return static_cast<double>(output);
-  };
-
-  auto requestRender = [this](
-                           std::function<void(double)> onRender,
-                           jsi::Runtime &rt) { this->requestRender(onRender); };
-
-#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,
-                          const jsi::String &propName) -> jsi::Value {
-    auto method =
-        javaPart_->getClass()
-            ->getMethod<jni::local_ref<JString>(int, jni::local_ref<JString>)>(
-                "obtainProp");
-    local_ref<JString> propNameJStr =
-        jni::make_jstring(propName.utf8(rt).c_str());
-    auto result = method(javaPart_.get(), viewTag, propNameJStr);
-    std::string str = result->toStdString();
-    return jsi::Value(rt, jsi::String::createFromAscii(rt, str.c_str()));
-  };
-
-  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,
-          int iosReferenceFrame,
-          std::function<void(double[], int)> setter) -> int {
-    return this->registerSensor(sensorType, interval, std::move(setter));
-  };
-  auto unregisterSensorFunction = [this](int sensorId) {
-    unregisterSensor(sensorId);
-  };
-
-  auto setGestureStateFunction = [this](int handlerTag, int newState) -> void {
-    setGestureState(handlerTag, newState);
-  };
-
-  auto subscribeForKeyboardEventsFunction =
-      [this](
-          std::function<void(int, int)> keyboardEventDataUpdater,
-          bool isStatusBarTranslucent) -> int {
-    return subscribeForKeyboardEvents(
-        std::move(keyboardEventDataUpdater), isStatusBarTranslucent);
-  };
-
-  auto unsubscribeFromKeyboardEventsFunction = [this](int listenerId) -> void {
-    unsubscribeFromKeyboardEvents(listenerId);
-  };
-
   auto jsQueue = std::make_shared<JMessageQueueThread>(messageQueueThread);
   std::shared_ptr<jsi::Runtime> animatedRuntime =
       ReanimatedRuntime::make(runtime_, jsQueue);
 
-  auto &rt = *runtime_;
-
-  auto workletRuntimeValue =
-      rt.global()
-          .getPropertyAsObject(rt, "ArrayBuffer")
-          .asFunction(rt)
-          .callAsConstructor(rt, {static_cast<double>(sizeof(void *))});
-  uintptr_t *workletRuntimeData = reinterpret_cast<uintptr_t *>(
-      workletRuntimeValue.getObject(rt).getArrayBuffer(rt).data(rt));
-  workletRuntimeData[0] = reinterpret_cast<uintptr_t>(animatedRuntime.get());
-
-  rt.global().setProperty(rt, "_WORKLET_RUNTIME", workletRuntimeValue);
-
-#ifdef RCT_NEW_ARCH_ENABLED
-  rt.global().setProperty(rt, "_IS_FABRIC", true);
-#else
-  rt.global().setProperty(rt, "_IS_FABRIC", false);
-#endif
-
-  auto version = getReanimatedVersionString(rt);
-  rt.global().setProperty(rt, "_REANIMATED_VERSION_CPP", version);
-
   std::shared_ptr<ErrorHandler> errorHandler =
       std::make_shared<AndroidErrorHandler>(scheduler_);
-  std::weak_ptr<jsi::Runtime> wrt = animatedRuntime;
-
-  auto progressLayoutAnimation =
-      [this, wrt](
-          int tag, const jsi::Object &newProps, bool isSharedTransition) {
-        auto newPropsJNI = JNIHelper::ConvertToPropsMap(*wrt.lock(), newProps);
-        this->layoutAnimations->cthis()->progressLayoutAnimation(
-            tag, newPropsJNI, isSharedTransition);
-      };
-
-  auto endLayoutAnimation = [this](int tag, bool isCancelled, bool removeView) {
-    this->layoutAnimations->cthis()->endLayoutAnimation(
-        tag, isCancelled, removeView);
-  };
-
-  PlatformDepMethodsHolder platformDepMethodsHolder = {
-      requestRender,
-#ifdef RCT_NEW_ARCH_ENABLED
-      synchronouslyUpdateUIPropsFunction,
-#else
-      updatePropsFunction,
-      scrollToFunction,
-      measureFunction,
-      configurePropsFunction,
-#endif
-      getCurrentTime,
-      progressLayoutAnimation,
-      endLayoutAnimation,
-      registerSensorFunction,
-      unregisterSensorFunction,
-      setGestureStateFunction,
-      subscribeForKeyboardEventsFunction,
-      unsubscribeFromKeyboardEventsFunction,
-  };
 
   auto module = std::make_shared<NativeReanimatedModule>(
       jsCallInvoker_,
@@ -269,52 +123,12 @@ void NativeProxy::installJSIBindings(
 #ifdef RCT_NEW_ARCH_ENABLED
   // nothing
 #else
-      propObtainer,
+      bindThis(&NativeProxy::obtainProp),
 #endif
-      platformDepMethodsHolder);
+      getPlatformDependentMethods());
 
   scheduler_->setRuntimeManager(module);
-
-  _nativeReanimatedModule = module;
-  std::weak_ptr<NativeReanimatedModule> weakModule = module;
-
-  this->registerEventHandler([weakModule, getCurrentTime](
-                                 jni::alias_ref<JString> eventKey,
-                                 jni::alias_ref<react::WritableMap> event) {
-    // handles RCTEvents from RNGestureHandler
-    if (auto module = weakModule.lock()) {
-      auto eventName = eventKey->toString();
-
-      // TODO: convert event directly to jsi::Value without JSON serialization
-      std::string eventAsString;
-      try {
-        eventAsString = event->toString();
-      } catch (std::exception &) {
-        // Events from other libraries may contain NaN or INF values which
-        // cannot be represented in JSON. See
-        // https://github.com/software-mansion/react-native-reanimated/issues/1776
-        // for details.
-        return;
-      }
-      std::string eventJSON = eventAsString.substr(
-          13, eventAsString.length() - 15); // removes "{ NativeMap: " and " }"
-      if (eventJSON == "null") {
-        return;
-      }
-
-      jsi::Runtime &rt = *module->runtime;
-      jsi::Value payload;
-      try {
-        payload = jsi::Value::createFromJsonUtf8(
-            rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
-      } catch (std::exception &) {
-        // Ignore events with malformed JSON payload.
-        return;
-      }
-
-      module->handleEvent(eventName, payload, getCurrentTime());
-    }
-  });
+  nativeReanimatedModule_ = module;
 
 #ifdef RCT_NEW_ARCH_ENABLED
   Binding *binding = fabricUIManager->getBinding();
@@ -323,99 +137,19 @@ void NativeProxy::installJSIBindings(
   module->setUIManager(uiManager);
   module->setNewestShadowNodesRegistry(newestShadowNodesRegistry_);
   newestShadowNodesRegistry_ = nullptr;
+//  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_);
 #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_);
-
-  std::weak_ptr<ErrorHandler> weakErrorHandler = errorHandler;
-
-  layoutAnimations->cthis()->setAnimationStartingBlock(
-      [wrt, weakModule, weakErrorHandler](
-          int tag, int type, alias_ref<JMap<jstring, jstring>> values) {
-        auto &rt = *wrt.lock();
-        jsi::Object yogaValues(rt);
-        for (const auto &entry : *values) {
-          try {
-            std::string keyString = entry.first->toStdString();
-            std::string valueString = entry.second->toStdString();
-            auto key = jsi::String::createFromAscii(rt, keyString);
-            if (keyString == "currentTransformMatrix" ||
-                keyString == "targetTransformMatrix") {
-              jsi::Array matrix =
-                  jsi_utils::convertStringToArray(rt, valueString, 9);
-              yogaValues.setProperty(rt, key, matrix);
-            } else {
-              auto value = stod(valueString);
-              yogaValues.setProperty(rt, key, value);
-            }
-          } catch (std::invalid_argument e) {
-            if (auto errorHandler = weakErrorHandler.lock()) {
-              errorHandler->setError("Failed to convert value to number");
-              errorHandler->raise();
-            }
-          }
-        }
-
-        auto reaModule = weakModule.lock();
-        if (reaModule == nullptr) {
-          return;
-        }
-
-        reaModule->layoutAnimationsManager().startLayoutAnimation(
-            rt, tag, static_cast<LayoutAnimationType>(type), yogaValues);
-      });
-
-  layoutAnimations->cthis()->setHasAnimationBlock(
-      [weakModule](int tag, int type) {
-        auto reaModule = weakModule.lock();
-        if (reaModule == nullptr) {
-          return false;
-        }
-
-        return reaModule->layoutAnimationsManager().hasLayoutAnimation(
-            tag, static_cast<LayoutAnimationType>(type));
-      });
-
-  layoutAnimations->cthis()->setClearAnimationConfigBlock(
-      [weakModule](int tag) {
-        auto reaModule = weakModule.lock();
-        if (reaModule == nullptr) {
-          return;
-        }
 
-        reaModule->layoutAnimationsManager().clearLayoutAnimationConfig(tag);
-      });
-
-  layoutAnimations->cthis()->setCancelAnimationForTag(
-      [wrt, weakModule](
-          int tag, int type, jboolean cancelled, jboolean removeView) {
-        if (auto reaModule = weakModule.lock()) {
-          if (auto runtime = wrt.lock()) {
-            jsi::Runtime &rt = *runtime;
-            reaModule->layoutAnimationsManager().cancelLayoutAnimation(
-                rt,
-                tag,
-                static_cast<LayoutAnimationType>(type),
-                cancelled,
-                removeView);
-          }
-        }
-      });
-
-  layoutAnimations->cthis()->setFindPrecedingViewTagForTransition(
-      [weakModule](int tag) {
-        if (auto module = weakModule.lock()) {
-          return module->layoutAnimationsManager()
-              .findPrecedingViewTagForTransition(tag);
-        } else {
-          return -1;
-        }
-      });
+  auto &rt = *runtime_;
+  setGlobalProperties(rt, animatedRuntime);
+  registerEventHandler();
+  setupLayoutAnimations();
 
   rt.global().setProperty(
       rt,
@@ -424,12 +158,12 @@ void NativeProxy::installJSIBindings(
 }
 
 bool NativeProxy::isAnyHandlerWaitingForEvent(std::string s) {
-  return _nativeReanimatedModule->isAnyHandlerWaitingForEvent(s);
+  return nativeReanimatedModule_->isAnyHandlerWaitingForEvent(s);
 }
 
 void NativeProxy::performOperations() {
 #ifdef RCT_NEW_ARCH_ENABLED
-  _nativeReanimatedModule->performOperations();
+  nativeReanimatedModule_->performOperations();
 #endif
 }
 
@@ -443,52 +177,84 @@ void NativeProxy::registerNatives() {
        makeNativeMethod("performOperations", NativeProxy::performOperations)});
 }
 
-void NativeProxy::requestRender(std::function<void(double)> onRender) {
-  static auto method =
-      javaPart_->getClass()
-          ->getMethod<void(AnimationFrameCallback::javaobject)>(
-              "requestRender");
+void NativeProxy::requestRender(
+    std::function<void(double)> onRender,
+    jsi::Runtime &rt) {
+  static const auto method =
+      getJniMethod<void(AnimationFrameCallback::javaobject)>("requestRender");
   method(
       javaPart_.get(),
       AnimationFrameCallback::newObjectCxxArgs(std::move(onRender)).get());
 }
 
-void NativeProxy::registerEventHandler(
-    std::function<
-        void(jni::alias_ref<JString>, jni::alias_ref<react::WritableMap>)>
-        handler) {
-  static auto method =
-      javaPart_->getClass()->getMethod<void(EventHandler::javaobject)>(
-          "registerEventHandler");
+void NativeProxy::registerEventHandler() {
+  auto eventHandler = bindThis(&NativeProxy::handleEvent);
+  static const auto method =
+      getJniMethod<void(EventHandler::javaobject)>("registerEventHandler");
   method(
       javaPart_.get(),
-      EventHandler::newObjectCxxArgs(std::move(handler)).get());
+      EventHandler::newObjectCxxArgs(std::move(eventHandler)).get());
+}
+
+void NativeProxy::maybeFlushUIUpdatesQueue() {
+  static const auto method = getJniMethod<void()>("maybeFlushUIUpdatesQueue");
+  method(javaPart_.get());
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
 // nothing
 #else
+jsi::Value NativeProxy::obtainProp(
+    jsi::Runtime &rt,
+    const int viewTag,
+    const jsi::String &propName) {
+  static const auto method =
+      getJniMethod<jni::local_ref<JString>(int, jni::local_ref<JString>)>(
+          "obtainProp");
+  local_ref<JString> propNameJStr =
+      jni::make_jstring(propName.utf8(rt).c_str());
+  auto result = method(javaPart_.get(), viewTag, propNameJStr);
+  std::string str = result->toStdString();
+  return jsi::Value(rt, jsi::String::createFromAscii(rt, str));
+}
+
+void NativeProxy::configureProps(
+    jsi::Runtime &rt,
+    const jsi::Value &uiProps,
+    const jsi::Value &nativeProps) {
+  static const auto method = getJniMethod<void(
+      ReadableNativeArray::javaobject, ReadableNativeArray::javaobject)>(
+      "configureProps");
+  method(
+      javaPart_.get(),
+      ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, uiProps))
+          .get(),
+      ReadableNativeArray::newObjectCxxArgs(
+          jsi::dynamicFromValue(rt, nativeProps))
+          .get());
+}
+
 void NativeProxy::updateProps(
     jsi::Runtime &rt,
     int viewTag,
+    const jsi::Value &viewName,
     const jsi::Object &props) {
-  auto method = javaPart_->getClass()
-                    ->getMethod<void(int, JMap<JString, JObject>::javaobject)>(
-                        "updateProps");
+  static const auto method =
+      getJniMethod<void(int, JMap<JString, JObject>::javaobject)>(
+          "updateProps");
   method(
       javaPart_.get(), viewTag, JNIHelper::ConvertToPropsMap(rt, props).get());
 }
 
 void NativeProxy::scrollTo(int viewTag, double x, double y, bool animated) {
-  auto method =
-      javaPart_->getClass()->getMethod<void(int, double, double, bool)>(
-          "scrollTo");
+  static const auto method =
+      getJniMethod<void(int, double, double, bool)>("scrollTo");
   method(javaPart_.get(), viewTag, x, y, animated);
 }
 
 std::vector<std::pair<std::string, double>> NativeProxy::measure(int viewTag) {
-  auto method =
-      javaPart_->getClass()->getMethod<local_ref<JArrayFloat>(int)>("measure");
+  static const auto method =
+      getJniMethod<local_ref<JArrayFloat>(int)>("measure");
   local_ref<JArrayFloat> output = method(javaPart_.get(), viewTag);
   size_t size = output->size();
   auto elements = output->getRegion(0, size);
@@ -518,9 +284,8 @@ void NativeProxy::synchronouslyUpdateUIProps(
     Tag tag,
     const jsi::Value &props) {
   static const auto method =
-      javaPart_->getClass()
-          ->getMethod<void(int, jni::local_ref<ReadableMap::javaobject>)>(
-              "synchronouslyUpdateUIProps");
+      getJniMethod<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);
@@ -530,10 +295,10 @@ void NativeProxy::synchronouslyUpdateUIProps(
 int NativeProxy::registerSensor(
     int sensorType,
     int interval,
+    int iosReferenceFrame,
     std::function<void(double[], int)> setter) {
-  static auto method =
-      javaPart_->getClass()->getMethod<int(int, int, SensorSetter::javaobject)>(
-          "registerSensor");
+  static const auto method =
+      getJniMethod<int(int, int, SensorSetter::javaobject)>("registerSensor");
   return method(
       javaPart_.get(),
       sensorType,
@@ -541,40 +306,21 @@ int NativeProxy::registerSensor(
       SensorSetter::newObjectCxxArgs(std::move(setter)).get());
 }
 void NativeProxy::unregisterSensor(int sensorId) {
-  auto method = javaPart_->getClass()->getMethod<void(int)>("unregisterSensor");
+  static const auto method = getJniMethod<void(int)>("unregisterSensor");
   method(javaPart_.get(), sensorId);
 }
 
 void NativeProxy::setGestureState(int handlerTag, int newState) {
-  auto method =
-      javaPart_->getClass()->getMethod<void(int, int)>("setGestureState");
+  static const auto method = getJniMethod<void(int, int)>("setGestureState");
   method(javaPart_.get(), handlerTag, newState);
 }
 
-void NativeProxy::configureProps(
-    jsi::Runtime &rt,
-    const jsi::Value &uiProps,
-    const jsi::Value &nativeProps) {
-  auto method = javaPart_->getClass()
-                    ->getMethod<void(
-                        ReadableNativeArray::javaobject,
-                        ReadableNativeArray::javaobject)>("configureProps");
-  method(
-      javaPart_.get(),
-      ReadableNativeArray::newObjectCxxArgs(jsi::dynamicFromValue(rt, uiProps))
-          .get(),
-      ReadableNativeArray::newObjectCxxArgs(
-          jsi::dynamicFromValue(rt, nativeProps))
-          .get());
-}
-
 int NativeProxy::subscribeForKeyboardEvents(
     std::function<void(int, int)> keyboardEventDataUpdater,
     bool isStatusBarTranslucent) {
-  auto method =
-      javaPart_->getClass()
-          ->getMethod<int(KeyboardEventDataUpdater::javaobject, bool)>(
-              "subscribeForKeyboardEvents");
+  static const auto method =
+      getJniMethod<int(KeyboardEventDataUpdater::javaobject, bool)>(
+          "subscribeForKeyboardEvents");
   return method(
       javaPart_.get(),
       KeyboardEventDataUpdater::newObjectCxxArgs(
@@ -584,9 +330,242 @@ int NativeProxy::subscribeForKeyboardEvents(
 }
 
 void NativeProxy::unsubscribeFromKeyboardEvents(int listenerId) {
-  auto method = javaPart_->getClass()->getMethod<void(int)>(
-      "unsubscribeFromKeyboardEvents");
+  static const auto method =
+      getJniMethod<void(int)>("unsubscribeFromKeyboardEvents");
   method(javaPart_.get(), listenerId);
 }
 
+double NativeProxy::getCurrentTime() {
+  static const auto method = getJniMethod<jlong()>("getCurrentTime");
+  jlong output = method(javaPart_.get());
+  return static_cast<double>(output);
+}
+
+void NativeProxy::handleEvent(
+    jni::alias_ref<JString> eventKey,
+    jni::alias_ref<react::WritableMap> event) {
+  // handles RCTEvents from RNGestureHandler
+  auto eventName = eventKey->toString();
+
+  // TODO: convert event directly to jsi::Value without JSON serialization
+  std::string eventAsString;
+  try {
+    eventAsString = event->toString();
+  } catch (std::exception &) {
+    // Events from other libraries may contain NaN or INF values which
+    // cannot be represented in JSON. See
+    // https://github.com/software-mansion/react-native-reanimated/issues/1776
+    // for details.
+    return;
+  }
+#if REACT_NATIVE_MINOR_VERSION >= 72
+  std::string eventJSON = eventAsString;
+#else
+  // remove "{ NativeMap: " and " }"
+  std::string eventJSON = eventAsString.substr(13, eventAsString.length() - 15);
+#endif
+  if (eventJSON == "null") {
+    return;
+  }
+
+  jsi::Runtime &rt = *nativeReanimatedModule_->runtime;
+  jsi::Value payload;
+  try {
+    payload = jsi::Value::createFromJsonUtf8(
+        rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
+  } catch (std::exception &) {
+    // Ignore events with malformed JSON payload.
+    return;
+  }
+
+  nativeReanimatedModule_->handleEvent(
+      eventName, payload, this->getCurrentTime());
+}
+
+void NativeProxy::progressLayoutAnimation(
+    int tag,
+    const jsi::Object &newProps,
+    bool isSharedTransition) {
+  auto &rt = *nativeReanimatedModule_->runtime;
+  auto newPropsJNI = JNIHelper::ConvertToPropsMap(rt, newProps);
+  layoutAnimations_->cthis()->progressLayoutAnimation(
+      tag, newPropsJNI, isSharedTransition);
+}
+
+PlatformDepMethodsHolder NativeProxy::getPlatformDependentMethods() {
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  auto updatePropsFunction = bindThis(&NativeProxy::updateProps);
+
+  auto measureFunction = bindThis(&NativeProxy::measure);
+
+  auto scrollToFunction = bindThis(&NativeProxy::scrollTo);
+#endif
+
+  auto getCurrentTime = bindThis(&NativeProxy::getCurrentTime);
+
+  auto requestRender = bindThis(&NativeProxy::requestRender);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  auto synchronouslyUpdateUIPropsFunction =
+      bindThis(&NativeProxy::synchronouslyUpdateUIProps);
+#else
+  auto configurePropsFunction = bindThis(&NativeProxy::configureProps);
+#endif
+
+  auto registerSensorFunction = bindThis(&NativeProxy::registerSensor);
+  auto unregisterSensorFunction = bindThis(&NativeProxy::unregisterSensor);
+
+  auto setGestureStateFunction = bindThis(&NativeProxy::setGestureState);
+
+  auto subscribeForKeyboardEventsFunction =
+      bindThis(&NativeProxy::subscribeForKeyboardEvents);
+
+  auto unsubscribeFromKeyboardEventsFunction =
+      bindThis(&NativeProxy::unsubscribeFromKeyboardEvents);
+
+  auto progressLayoutAnimation =
+      bindThis(&NativeProxy::progressLayoutAnimation);
+
+  auto endLayoutAnimation = [this](int tag, bool isCancelled, bool removeView) {
+    this->layoutAnimations_->cthis()->endLayoutAnimation(
+        tag, isCancelled, removeView);
+  };
+
+  auto maybeFlushUiUpdatesQueueFunction =
+      bindThis(&NativeProxy::maybeFlushUIUpdatesQueue);
+
+  return {
+      requestRender,
+#ifdef RCT_NEW_ARCH_ENABLED
+      synchronouslyUpdateUIPropsFunction,
+#else
+      updatePropsFunction,
+      scrollToFunction,
+      measureFunction,
+      configurePropsFunction,
+#endif
+      getCurrentTime,
+      progressLayoutAnimation,
+      endLayoutAnimation,
+      registerSensorFunction,
+      unregisterSensorFunction,
+      setGestureStateFunction,
+      subscribeForKeyboardEventsFunction,
+      unsubscribeFromKeyboardEventsFunction,
+      maybeFlushUiUpdatesQueueFunction,
+  };
+}
+
+void NativeProxy::setGlobalProperties(
+    jsi::Runtime &jsRuntime,
+    const std::shared_ptr<jsi::Runtime> &reanimatedRuntime) {
+  auto workletRuntimeValue =
+      jsRuntime.global()
+          .getPropertyAsObject(jsRuntime, "ArrayBuffer")
+          .asFunction(jsRuntime)
+          .callAsConstructor(jsRuntime, {static_cast<double>(sizeof(void *))});
+  uintptr_t *workletRuntimeData = reinterpret_cast<uintptr_t *>(
+      workletRuntimeValue.getObject(jsRuntime).getArrayBuffer(jsRuntime).data(
+          jsRuntime));
+  workletRuntimeData[0] = reinterpret_cast<uintptr_t>(reanimatedRuntime.get());
+
+  jsRuntime.global().setProperty(
+      jsRuntime, "_WORKLET_RUNTIME", workletRuntimeValue);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  jsRuntime.global().setProperty(jsRuntime, "_IS_FABRIC", true);
+#else
+  jsRuntime.global().setProperty(jsRuntime, "_IS_FABRIC", false);
+#endif
+
+  auto version = getReanimatedVersionString(jsRuntime);
+  jsRuntime.global().setProperty(jsRuntime, "_REANIMATED_VERSION_CPP", version);
+}
+
+void NativeProxy::setupLayoutAnimations() {
+  auto weakModule =
+      std::weak_ptr<NativeReanimatedModule>(nativeReanimatedModule_);
+
+  layoutAnimations_->cthis()->setAnimationStartingBlock(
+      [weakModule](
+          int tag, int type, alias_ref<JMap<jstring, jstring>> values) {
+        auto module = weakModule.lock();
+        if (module == nullptr) {
+          return;
+        }
+        auto &rt = *module->runtime;
+        auto errorHandler = module->errorHandler;
+
+        jsi::Object yogaValues(rt);
+        for (const auto &entry : *values) {
+          try {
+            std::string keyString = entry.first->toStdString();
+            std::string valueString = entry.second->toStdString();
+            auto key = jsi::String::createFromAscii(rt, keyString);
+            if (keyString == "currentTransformMatrix" ||
+                keyString == "targetTransformMatrix") {
+              jsi::Array matrix =
+                  jsi_utils::convertStringToArray(rt, valueString, 9);
+              yogaValues.setProperty(rt, key, matrix);
+            } else {
+              auto value = stod(valueString);
+              yogaValues.setProperty(rt, key, value);
+            }
+          } catch (std::invalid_argument e) {
+            errorHandler->setError("Failed to convert value to number");
+            errorHandler->raise();
+          }
+        }
+
+        module->layoutAnimationsManager().startLayoutAnimation(
+            rt, tag, static_cast<LayoutAnimationType>(type), yogaValues);
+      });
+
+  layoutAnimations_->cthis()->setHasAnimationBlock(
+      [weakModule](int tag, int type) {
+        auto module = weakModule.lock();
+        if (module == nullptr) {
+          return false;
+        }
+
+        return module->layoutAnimationsManager().hasLayoutAnimation(
+            tag, static_cast<LayoutAnimationType>(type));
+      });
+
+  layoutAnimations_->cthis()->setClearAnimationConfigBlock(
+      [weakModule](int tag) {
+        auto module = weakModule.lock();
+        if (module == nullptr) {
+          return;
+        }
+
+        module->layoutAnimationsManager().clearLayoutAnimationConfig(tag);
+      });
+
+  layoutAnimations_->cthis()->setCancelAnimationForTag(
+      [weakModule](int tag, int type, jboolean cancelled, jboolean removeView) {
+        if (auto module = weakModule.lock()) {
+          jsi::Runtime &rt = *module->runtime;
+          module->layoutAnimationsManager().cancelLayoutAnimation(
+              rt,
+              tag,
+              static_cast<LayoutAnimationType>(type),
+              cancelled,
+              removeView);
+        }
+      });
+
+  layoutAnimations_->cthis()->setFindPrecedingViewTagForTransition(
+      [weakModule](int tag) {
+        if (auto module = weakModule.lock()) {
+          return module->layoutAnimationsManager()
+              .findPrecedingViewTagForTransition(tag);
+        } else {
+          return -1;
+        }
+      });
+}
+
 } // namespace reanimated