@react-native-ohos/react-native-reanimated 3.18.1-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h

@@ -0,0 +1,252 @@
+#pragma once
+
+#include <reanimated/AnimatedSensor/AnimatedSensorModule.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/NativeModules/ReanimatedModuleProxySpec.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <reanimated/Fabric/PropsRegistry.h>
+#include <reanimated/Fabric/ReanimatedCommitHook.h>
+#include <reanimated/Fabric/ReanimatedMountHook.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/Registries/EventHandlerRegistry.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/SingleInstanceChecker.h>
+#include <worklets/Tools/UIScheduler.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/UIManager.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+using namespace facebook;
+
+class ReanimatedModuleProxy
+    : public ReanimatedModuleProxySpec,
+      public std::enable_shared_from_this<ReanimatedModuleProxy> {
+ public:
+  ReanimatedModuleProxy(
+      const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy,
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      const PlatformDepMethodsHolder &platformDepMethodsHolder,
+      const bool isBridgeless,
+      const bool isReducedMotion);
+
+  // We need this init method to initialize callbacks with
+  // weak_from_this() which is available only after the object
+  // is fully constructed.
+  void init(const PlatformDepMethodsHolder &platformDepMethodsHolder);
+
+  void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) override;
+  jsi::Value executeOnUIRuntimeSync(jsi::Runtime &rt, const jsi::Value &worklet)
+      override;
+
+  jsi::Value createWorkletRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &name,
+      const jsi::Value &initializer) override;
+  jsi::Value scheduleOnRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &workletRuntimeValue,
+      const jsi::Value &shareableWorkletValue) override;
+
+  ~ReanimatedModuleProxy();
+
+  jsi::Value registerEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet,
+      const jsi::Value &eventName,
+      const jsi::Value &emitterReactTag) override;
+  void unregisterEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &registrationId) override;
+
+  jsi::Value getViewProp(
+      jsi::Runtime &rt,
+#ifdef RCT_NEW_ARCH_ENABLED
+      const jsi::Value &shadowNodeWrapper,
+#else
+      const jsi::Value &viewTag,
+#endif
+      const jsi::Value &propName,
+      const jsi::Value &callback) override;
+
+  jsi::Value enableLayoutAnimations(jsi::Runtime &rt, const jsi::Value &config)
+      override;
+  jsi::Value configureProps(
+      jsi::Runtime &rt,
+      const jsi::Value &uiProps,
+      const jsi::Value &nativeProps) override;
+  jsi::Value configureLayoutAnimationBatch(
+      jsi::Runtime &rt,
+      const jsi::Value &layoutAnimationsBatch) override;
+  void setShouldAnimateExiting(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &shouldAnimate) override;
+
+  void onRender(double timestampMs);
+
+  bool isAnyHandlerWaitingForEvent(
+      const std::string &eventName,
+      const int emitterReactTag);
+
+  void maybeRequestRender();
+
+  bool handleEvent(
+      const std::string &eventName,
+      const int emitterReactTag,
+      const jsi::Value &payload,
+      double currentTime);
+
+  inline std::shared_ptr<JSLogger> getJSLogger() const {
+    return jsLogger_;
+  }
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  bool handleRawEvent(const RawEvent &rawEvent, double currentTime);
+
+  void updateProps(jsi::Runtime &rt, const jsi::Value &operations);
+
+  void removeFromPropsRegistry(jsi::Runtime &rt, const jsi::Value &viewTags);
+
+  void performOperations();
+
+  void markNodeAsRemovable(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeWrapper) override;
+  void unmarkNodeAsRemovable(jsi::Runtime &rt, const jsi::Value &viewTag)
+      override;
+
+  void dispatchCommand(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeValue,
+      const jsi::Value &commandNameValue,
+      const jsi::Value &argsValue);
+
+  jsi::String obtainProp(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeWrapper,
+      const jsi::Value &propName);
+
+  jsi::Value measure(jsi::Runtime &rt, const jsi::Value &shadowNodeValue);
+
+  void initializeFabric(const std::shared_ptr<UIManager> &uiManager);
+
+  void initializeLayoutAnimationsProxy();
+
+  std::string obtainPropFromShadowNode(
+      jsi::Runtime &rt,
+      const std::string &propName,
+      const ShadowNode::Shared &shadowNode);
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+  std::function<std::string()> createRegistriesLeakCheck();
+#endif // IS_REANIMATED_EXAMPLE_APP
+#endif
+
+  jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorType,
+      const jsi::Value &interval,
+      const jsi::Value &iosReferenceFrame,
+      const jsi::Value &sensorDataContainer) override;
+  void unregisterSensor(jsi::Runtime &rt, const jsi::Value &sensorId) override;
+
+  void cleanupSensors();
+
+  jsi::Value subscribeForKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &keyboardEventContainer,
+      const jsi::Value &isStatusBarTranslucent,
+      const jsi::Value &isNavigationBarTranslucent) override;
+  void unsubscribeFromKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &listenerId) override;
+
+  inline LayoutAnimationsManager &layoutAnimationsManager() {
+    return *layoutAnimationsManager_;
+  }
+
+  [[nodiscard]] inline jsi::Runtime &getUIRuntime() const {
+    return uiWorkletRuntime_->getJSIRuntime();
+  }
+
+  [[nodiscard]] inline bool isBridgeless() const {
+    return isBridgeless_;
+  }
+
+  [[nodiscard]] inline bool isReducedMotion() const {
+    return isReducedMotion_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<WorkletsModuleProxy>
+  getWorkletsModuleProxy() const {
+    return workletsModuleProxy_;
+  }
+
+ private:
+  void requestAnimationFrame(jsi::Runtime &rt, const jsi::Value &callback);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  jsi::Value filterNonAnimatableProps(
+      jsi::Runtime &rt,
+      const jsi::Value &props);
+#endif // RCT_NEW_ARCH_ENABLED
+
+  const bool isBridgeless_;
+  const bool isReducedMotion_;
+  std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
+  const std::string valueUnpackerCode_;
+  std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
+
+  std::unique_ptr<EventHandlerRegistry> eventHandlerRegistry_;
+  const RequestRenderFunction requestRender_;
+  std::vector<std::shared_ptr<jsi::Value>> frameCallbacks_;
+  volatile bool renderRequested_{false};
+  std::function<void(const double)> onRenderCallback_;
+  AnimatedSensorModule animatedSensorModule_;
+  const std::shared_ptr<JSLogger> jsLogger_;
+  std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  std::unordered_set<std::string>
+      animatablePropNames_; // filled by configureProps
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
+
+  std::vector<std::pair<ShadowNode::Shared, std::unique_ptr<jsi::Value>>>
+      operationsInBatch_; // TODO: refactor std::pair to custom struct
+
+  std::shared_ptr<PropsRegistry> propsRegistry_;
+  std::shared_ptr<ReanimatedCommitHook> commitHook_;
+  std::shared_ptr<ReanimatedMountHook> mountHook_;
+
+  std::vector<Tag> tagsToRemove_; // from `propsRegistry_`
+#else
+  const ObtainPropFunction obtainPropFunction_;
+  const ConfigurePropsFunction configurePropsPlatformFunction_;
+  const UpdatePropsFunction updatePropsFunction_;
+#endif
+
+  const KeyboardEventSubscribeFunction subscribeForKeyboardEventsFunction_;
+  const KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEventsFunction_;
+
+#ifndef NDEBUG
+  worklets::SingleInstanceChecker<ReanimatedModuleProxy> singleInstanceChecker_;
+#endif // NDEBUG
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxySpec.cpp

@@ -0,0 +1,231 @@
+#include <reanimated/NativeModules/ReanimatedModuleProxySpec.h>
+
+#include <utility>
+
+#define REANIMATED_SPEC_PREFIX(FN_NAME) \
+  __hostFunction_ReanimatedModuleProxySpec_##FN_NAME
+
+namespace reanimated {
+
+// scheduler
+
+static jsi::Value REANIMATED_SPEC_PREFIX(scheduleOnUI)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->scheduleOnUI(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(executeOnUIRuntimeSync)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->executeOnUIRuntimeSync(rt, std::move(args[0]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(createWorkletRuntime)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->createWorkletRuntime(rt, std::move(args[0]), std::move(args[1]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(scheduleOnRuntime)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->scheduleOnRuntime(rt, std::move(args[0]), std::move(args[1]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(registerEventHandler)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->registerEventHandler(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(unregisterEventHandler)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->unregisterEventHandler(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(getViewProp)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->getViewProp(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(enableLayoutAnimations)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->enableLayoutAnimations(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(registerSensor)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->registerSensor(
+          rt,
+          std::move(args[0]),
+          std::move(args[1]),
+          std::move(args[2]),
+          std::move(args[3]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(unregisterSensor)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->unregisterSensor(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(configureProps)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->configureProps(rt, std::move(args[0]), std::move(args[1]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(subscribeForKeyboardEvents)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->subscribeForKeyboardEvents(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(unsubscribeFromKeyboardEvents)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->unsubscribeFromKeyboardEvents(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(configureLayoutAnimationBatch)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->configureLayoutAnimationBatch(rt, std::move(args[0]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(setShouldAnimateExiting)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->setShouldAnimateExiting(rt, std::move(args[0]), std::move(args[1]));
+  return jsi::Value::undefined();
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+static jsi::Value REANIMATED_SPEC_PREFIX(markNodeAsRemovable)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->markNodeAsRemovable(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(unmarkNodeAsRemovable)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->unmarkNodeAsRemovable(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+ReanimatedModuleProxySpec::ReanimatedModuleProxySpec(
+    const std::shared_ptr<CallInvoker> &jsInvoker)
+    : TurboModule("NativeReanimated", jsInvoker) {
+  methodMap_["scheduleOnUI"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(scheduleOnUI)};
+  methodMap_["executeOnUIRuntimeSync"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(executeOnUIRuntimeSync)};
+  methodMap_["createWorkletRuntime"] =
+      MethodMetadata{2, REANIMATED_SPEC_PREFIX(createWorkletRuntime)};
+  methodMap_["scheduleOnRuntime"] =
+      MethodMetadata{2, REANIMATED_SPEC_PREFIX(scheduleOnRuntime)};
+
+  methodMap_["registerEventHandler"] =
+      MethodMetadata{3, REANIMATED_SPEC_PREFIX(registerEventHandler)};
+  methodMap_["unregisterEventHandler"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterEventHandler)};
+
+  methodMap_["getViewProp"] =
+      MethodMetadata{3, REANIMATED_SPEC_PREFIX(getViewProp)};
+  methodMap_["enableLayoutAnimations"] =
+      MethodMetadata{2, REANIMATED_SPEC_PREFIX(enableLayoutAnimations)};
+  methodMap_["registerSensor"] =
+      MethodMetadata{4, REANIMATED_SPEC_PREFIX(registerSensor)};
+  methodMap_["unregisterSensor"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterSensor)};
+  methodMap_["configureProps"] =
+      MethodMetadata{2, REANIMATED_SPEC_PREFIX(configureProps)};
+  methodMap_["subscribeForKeyboardEvents"] =
+      MethodMetadata{2, REANIMATED_SPEC_PREFIX(subscribeForKeyboardEvents)};
+  methodMap_["unsubscribeFromKeyboardEvents"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unsubscribeFromKeyboardEvents)};
+
+  methodMap_["configureLayoutAnimationBatch"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(configureLayoutAnimationBatch)};
+  methodMap_["setShouldAnimateExitingForTag"] =
+      MethodMetadata{2, REANIMATED_SPEC_PREFIX(setShouldAnimateExiting)};
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  methodMap_["markNodeAsRemovable"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(markNodeAsRemovable)};
+  methodMap_["unmarkNodeAsRemovable"] =
+      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unmarkNodeAsRemovable)};
+#endif // RCT_NEW_ARCH_ENABLED
+}
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxySpec.h

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class JSI_EXPORT ReanimatedModuleProxySpec : public TurboModule {
+ protected:
+  explicit ReanimatedModuleProxySpec(
+      const std::shared_ptr<CallInvoker> &jsInvoker);
+
+ public:
+  // Scheduling
+  virtual void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) = 0;
+  virtual jsi::Value executeOnUIRuntimeSync(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet) = 0;
+
+  // Worklet runtime
+  virtual jsi::Value createWorkletRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &name,
+      const jsi::Value &initializer) = 0;
+  virtual jsi::Value scheduleOnRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &workletRuntimeValue,
+      const jsi::Value &shareableWorkletValue) = 0;
+
+  // events
+  virtual jsi::Value registerEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet,
+      const jsi::Value &eventName,
+      const jsi::Value &emitterReactTag) = 0;
+  virtual void unregisterEventHandler(
+      jsi::Runtime &rt,
+      const jsi::Value &registrationId) = 0;
+
+  // views
+  virtual jsi::Value getViewProp(
+      jsi::Runtime &rt,
+#ifdef RCT_NEW_ARCH_ENABLED
+      const jsi::Value &shadowNodeWrapper,
+#else
+      const jsi::Value &viewTag,
+#endif
+      const jsi::Value &propName,
+      const jsi::Value &callback) = 0;
+
+  // sensors
+  virtual jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorType,
+      const jsi::Value &interval,
+      const jsi::Value &iosReferenceFrame,
+      const jsi::Value &sensorDataContainer) = 0;
+  virtual void unregisterSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorId) = 0;
+
+  // keyboard
+  virtual jsi::Value subscribeForKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &keyboardEventContainer,
+      const jsi::Value &isStatusBarTranslucent,
+      const jsi::Value &isNavigationBarTranslucent) = 0;
+  virtual void unsubscribeFromKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &listenerId) = 0;
+
+  // other
+  virtual jsi::Value enableLayoutAnimations(
+      jsi::Runtime &rt,
+      const jsi::Value &config) = 0;
+  virtual jsi::Value configureProps(
+      jsi::Runtime &rt,
+      const jsi::Value &uiProps,
+      const jsi::Value &nativeProps) = 0;
+
+  // layout animations
+  virtual jsi::Value configureLayoutAnimationBatch(
+      jsi::Runtime &rt,
+      const jsi::Value &layoutAnimationsBatch) = 0;
+
+  virtual void setShouldAnimateExiting(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &shouldAnimate) = 0;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  // Cleanup
+  virtual void markNodeAsRemovable(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeWrapper) = 0;
+  virtual void unmarkNodeAsRemovable(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag) = 0;
+#endif // RCT_NEW_ARCH_ENABLED
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/RuntimeDecorators/RNRuntimeDecorator.cpp

@@ -0,0 +1,56 @@
+#include <reanimated/RuntimeDecorators/RNRuntimeDecorator.h>
+#include <worklets/Tools/ReanimatedJSIUtils.h>
+#include <worklets/Tools/ReanimatedVersion.h>
+
+namespace reanimated {
+
+void RNRuntimeDecorator::decorate(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<ReanimatedModuleProxy> &reanimatedModuleProxy) {
+  jsi::Runtime &uiRuntime = reanimatedModuleProxy->getUIRuntime();
+  auto workletRuntimeValue =
+      rnRuntime.global()
+          .getPropertyAsObject(rnRuntime, "ArrayBuffer")
+          .asFunction(rnRuntime)
+          .callAsConstructor(rnRuntime, {static_cast<double>(sizeof(void *))});
+  uintptr_t *workletRuntimeData = reinterpret_cast<uintptr_t *>(
+      workletRuntimeValue.getObject(rnRuntime).getArrayBuffer(rnRuntime).data(
+          rnRuntime));
+  workletRuntimeData[0] = reinterpret_cast<uintptr_t>(&uiRuntime);
+  rnRuntime.global().setProperty(
+      rnRuntime, "_WORKLET_RUNTIME", workletRuntimeValue);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  constexpr auto isFabric = true;
+#else
+  constexpr auto isFabric = false;
+#endif // RCT_NEW_ARCH_ENABLED
+  rnRuntime.global().setProperty(rnRuntime, "_IS_FABRIC", isFabric);
+
+  rnRuntime.global().setProperty(
+      rnRuntime, "_IS_BRIDGELESS", reanimatedModuleProxy->isBridgeless());
+
+#ifndef NDEBUG
+  checkJSVersion(rnRuntime, reanimatedModuleProxy->getJSLogger());
+#endif // NDEBUG
+
+#if defined(IS_REANIMATED_EXAMPLE_APP) && defined(RCT_NEW_ARCH_ENABLED)
+  jsi_utils::installJsiFunction(
+      rnRuntime,
+      "_registriesLeakCheck",
+      reanimatedModuleProxy->createRegistriesLeakCheck());
+#endif // defined(IS_REANIMATED_EXAMPLE_APP) && defined(RCT_NEW_ARCH_ENABLED)
+  injectReanimatedCppVersion(rnRuntime);
+
+  rnRuntime.global().setProperty(
+      rnRuntime,
+      "_REANIMATED_IS_REDUCED_MOTION",
+      reanimatedModuleProxy->isReducedMotion());
+
+  rnRuntime.global().setProperty(
+      rnRuntime,
+      "__reanimatedModuleProxy",
+      jsi::Object::createFromHostObject(rnRuntime, reanimatedModuleProxy));
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/RuntimeDecorators/RNRuntimeDecorator.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <reanimated/NativeModules/ReanimatedModuleProxy.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace reanimated {
+
+class RNRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<ReanimatedModuleProxy> &reanimatedModuleProxy);
+};
+
+} // namespace reanimated