@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.1

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

@@ -1,56 +1,54 @@
-#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
+#include <reanimated/RuntimeDecorators/RNRuntimeDecorator.h>
+#include <reanimated/Tools/ReanimatedVersion.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <memory>
+
+namespace reanimated {
+
+void RNRuntimeDecorator::decorate(
+    jsi::Runtime &rnRuntime,
+    jsi::Runtime &uiRuntime,
+    const std::shared_ptr<ReanimatedModuleProxy> &reanimatedModuleProxy) {
+  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);
+
+#ifndef NDEBUG
+  checkJSVersion(rnRuntime, reanimatedModuleProxy->getJSLogger());
+#endif // NDEBUG
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+  installDebugBindings(rnRuntime, reanimatedModuleProxy);
+#endif // IS_REANIMATED_EXAMPLE_APP
+
+  injectReanimatedCppVersion(rnRuntime);
+
+  rnRuntime.global().setProperty(rnRuntime, "_REANIMATED_IS_REDUCED_MOTION", reanimatedModuleProxy->isReducedMotion());
+
+  rnRuntime.global().setProperty(
+      rnRuntime, "__reanimatedModuleProxy", jsi::Object::createFromHostObject(rnRuntime, reanimatedModuleProxy));
+}
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+void RNRuntimeDecorator::installDebugBindings(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<ReanimatedModuleProxy> &reanimatedModuleProxy) {
+#if TARGET_OS_X
+  jsi_utils::installJsiFunction(
+      rnRuntime, "__getTagFromShadowNodeWrapper", [](jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper) {
+        auto node = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeWrapper);
+        return jsi::Value(rt, static_cast<double>(node->getTag()));
+      });
+#endif // TARGET_OS_X
+
+  jsi_utils::installJsiFunction(rnRuntime, "_registriesLeakCheck", reanimatedModuleProxy->createRegistriesLeakCheck());
+}
+#endif // IS_REANIMATED_EXAMPLE_APP
+
+} // namespace reanimated

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

@@ -1,20 +1,28 @@
-#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
+#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,
+      jsi::Runtime &uiRuntime,
+      const std::shared_ptr<ReanimatedModuleProxy> &reanimatedModuleProxy);
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+ private:
+  static void installDebugBindings(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<ReanimatedModuleProxy> &reanimatedModuleProxy);
+#endif // IS_REANIMATED_EXAMPLE_APP
+};
+
+} // namespace reanimated

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

@@ -1,70 +1,58 @@
-#include <reanimated/RuntimeDecorators/UIRuntimeDecorator.h>
-#include <worklets/Tools/ReanimatedJSIUtils.h>
-
-namespace reanimated {
-
-using namespace worklets;
-
-void UIRuntimeDecorator::decorate(
-    jsi::Runtime &uiRuntime,
-#ifdef RCT_NEW_ARCH_ENABLED
-// nothing
-#else
-    const ScrollToFunction scrollTo,
-#endif
-    const ObtainPropFunction obtainPropFunction,
-    const UpdatePropsFunction updateProps,
-    const MeasureFunction measure,
-    const DispatchCommandFunction dispatchCommand,
-    const RequestAnimationFrameFunction requestAnimationFrame,
-    const GetAnimationTimestampFunction getAnimationTimestamp,
-    const SetGestureStateFunction setGestureState,
-    const ProgressLayoutAnimationFunction progressLayoutAnimation,
-    const EndLayoutAnimationFunction endLayoutAnimation,
-    const MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue) {
-  uiRuntime.global().setProperty(uiRuntime, "_UI", true);
-
-#ifdef RCT_NEW_ARCH_ENABLED
-  jsi_utils::installJsiFunction(uiRuntime, "_updatePropsFabric", updateProps);
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_dispatchCommandFabric", dispatchCommand);
-  jsi_utils::installJsiFunction(uiRuntime, "_measureFabric", measure);
-#else
-  jsi_utils::installJsiFunction(uiRuntime, "_updatePropsPaper", updateProps);
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_dispatchCommandPaper", dispatchCommand);
-  jsi_utils::installJsiFunction(uiRuntime, "_scrollToPaper", scrollTo);
-  jsi_utils::installJsiFunction(
-      uiRuntime,
-      "_measurePaper",
-      [measure](jsi::Runtime &rt, int viewTag) -> jsi::Value {
-        auto result = measure(viewTag);
-        jsi::Object resultObject(rt);
-        for (const auto &item : result) {
-          resultObject.setProperty(rt, item.first.c_str(), item.second);
-        }
-        return resultObject;
-      });
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_obtainPropPaper", obtainPropFunction);
-#endif // RCT_NEW_ARCH_ENABLED
-
-  jsi_utils::installJsiFunction(
-      uiRuntime, "requestAnimationFrame", requestAnimationFrame);
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_getAnimationTimestamp", getAnimationTimestamp);
-
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_notifyAboutProgress", progressLayoutAnimation);
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_notifyAboutEnd", endLayoutAnimation);
-
-  jsi_utils::installJsiFunction(uiRuntime, "_setGestureState", setGestureState);
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_maybeFlushUIUpdatesQueue", maybeFlushUIUpdatesQueue);
-
-  jsi_utils::installJsiFunction(
-      uiRuntime, "_obtainPropFabric", obtainPropFunction);
-}
-
-} // namespace reanimated
+#include <reanimated/RuntimeDecorators/UIRuntimeDecorator.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <utility>
+
+namespace reanimated {
+
+using namespace worklets;
+
+void UIRuntimeDecorator::decorate(
+    jsi::Runtime &uiRuntime,
+    ObtainPropFunction obtainPropFunction,
+    UpdatePropsFunction updateProps,
+    MeasureFunction measure,
+    DispatchCommandFunction dispatchCommand,
+    GetAnimationTimestampFunction getAnimationTimestamp,
+    SetGestureStateFunction setGestureState,
+    ProgressLayoutAnimationFunction progressLayoutAnimation,
+    EndLayoutAnimationFunction endLayoutAnimation,
+    MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue) {
+
+  jsi_utils::installJsiFunction(uiRuntime, "_updateProps", std::move(updateProps));
+  jsi_utils::installJsiFunction(uiRuntime, "_dispatchCommand", std::move(dispatchCommand));
+  jsi_utils::installJsiFunction(uiRuntime, "_measure", std::move(measure));
+  jsi_utils::installJsiFunction(uiRuntime, "_getAnimationTimestamp", std::move(getAnimationTimestamp));
+  jsi_utils::installJsiFunction(uiRuntime, "_notifyAboutProgress", std::move(progressLayoutAnimation));
+  jsi_utils::installJsiFunction(uiRuntime, "_notifyAboutEnd", std::move(endLayoutAnimation));
+  jsi_utils::installJsiFunction(uiRuntime, "_setGestureState", std::move(setGestureState));
+  jsi_utils::installJsiFunction(uiRuntime, "_obtainProp", std::move(obtainPropFunction));
+
+  subscribeForMicrotasksFinalization(uiRuntime, std::move(maybeFlushUIUpdatesQueue));
+}
+
+void UIRuntimeDecorator::subscribeForMicrotasksFinalization(
+    jsi::Runtime &uiRuntime,
+    MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue) {
+  auto maybeMicrotaskQueueFinalizers = uiRuntime.global().getProperty(uiRuntime, "_microtaskQueueFinalizers");
+
+  if (maybeMicrotaskQueueFinalizers.isUndefined()) {
+    throw std::runtime_error(
+        "[Reanimated] Expected microtaskQueueFinalizers to be defined. "
+        "Perhaps Worklets failed to initialize the UI Runtime?");
+  }
+
+  const auto microtaskQueueFinalizers = maybeMicrotaskQueueFinalizers.asObject(uiRuntime).asArray(uiRuntime);
+
+  microtaskQueueFinalizers.getPropertyAsFunction(uiRuntime, "push")
+      .callWithThis(
+          uiRuntime,
+          microtaskQueueFinalizers,
+          jsi::Function::createFromHostFunction(
+              uiRuntime,
+              jsi::PropNameID::forAscii(uiRuntime, "_maybeFlushUIUpdatesQueue"),
+              0,
+              jsi_utils::createHostFunction(std::move(maybeFlushUIUpdatesQueue))));
+}
+
+} // namespace reanimated

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

@@ -1,35 +1,31 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <reanimated/Tools/PlatformDepMethodsHolder.h>
-
-using namespace facebook;
-
-namespace reanimated {
-
-using RequestAnimationFrameFunction =
-    std::function<void(jsi::Runtime &, const jsi::Value &)>;
-
-class UIRuntimeDecorator {
- public:
-  static void decorate(
-      jsi::Runtime &uiRuntime,
-#ifdef RCT_NEW_ARCH_ENABLED
-// nothing
-#else
-      const ScrollToFunction scrollTo,
-#endif
-      const ObtainPropFunction obtainPropFunction,
-      const UpdatePropsFunction updateProps,
-      const MeasureFunction measure,
-      const DispatchCommandFunction dispatchCommand,
-      const RequestAnimationFrameFunction requestAnimationFrame,
-      const GetAnimationTimestampFunction getAnimationTimestamp,
-      const SetGestureStateFunction setGestureState,
-      const ProgressLayoutAnimationFunction progressLayoutAnimation,
-      const EndLayoutAnimationFunction endLayoutAnimation,
-      const MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue);
-};
-
-} // namespace reanimated
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+
+using namespace facebook;
+
+namespace reanimated {
+
+class UIRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &uiRuntime,
+      const ObtainPropFunction obtainPropFunction,
+      const UpdatePropsFunction updateProps,
+      const MeasureFunction measure,
+      const DispatchCommandFunction dispatchCommand,
+      const GetAnimationTimestampFunction getAnimationTimestamp,
+      const SetGestureStateFunction setGestureState,
+      const ProgressLayoutAnimationFunction progressLayoutAnimation,
+      const EndLayoutAnimationFunction endLayoutAnimation,
+      const MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue);
+
+ private:
+  static void subscribeForMicrotasksFinalization(
+      jsi::Runtime &uiRuntime,
+      MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue);
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/FeatureFlags.cpp

@@ -0,0 +1,18 @@
+#include <reanimated/Tools/FeatureFlags.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace reanimated {
+
+std::unordered_map<std::string, bool> DynamicFeatureFlags::flags_;
+
+bool DynamicFeatureFlags::getFlag(const std::string &name) {
+  return flags_.contains(name) && flags_[name];
+}
+
+void DynamicFeatureFlags::setFlag(const std::string &name, bool value) {
+  flags_[name] = value;
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/FeatureFlags.h

@@ -0,0 +1,44 @@
+#pragma once
+#include <string>
+#include <unordered_map>
+
+namespace reanimated {
+
+class StaticFeatureFlags {
+ public:
+#ifdef REANIMATED_FEATURE_FLAGS
+
+// Convert the value under x into a string
+#define XTOSTRING(x) #x
+// Evaluate the flag value; without this step, it would stringify the flag name
+// itself instead of the flag value
+#define TOSTRING(x) XTOSTRING(x)
+
+  static constexpr bool getFlag(const std::string_view &name) {
+    std::string nameStr = name.data();
+    std::string featureFlags = TOSTRING(REANIMATED_FEATURE_FLAGS);
+    if (featureFlags.find("[" + nameStr + ":") == std::string::npos) {
+      throw std::logic_error("Unable to recognize flag: " + nameStr);
+    }
+    return featureFlags.find("[" + nameStr + ":true]") != std::string::npos;
+  }
+
+#else
+
+  static constexpr bool getFlag(const std::string_view &) {
+    return false;
+  }
+
+#endif
+};
+
+class DynamicFeatureFlags {
+ public:
+  static bool getFlag(const std::string &name);
+  static void setFlag(const std::string &name, bool value);
+
+ private:
+  static std::unordered_map<std::string, bool> flags_;
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h

@@ -1,98 +1,67 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#ifdef RCT_NEW_ARCH_ENABLED
-#include <react/renderer/core/ReactPrimitives.h>
-#endif
-
-#include <string>
-#include <utility>
-#include <vector>
-
-using namespace facebook;
-
-#ifdef RCT_NEW_ARCH_ENABLED
-using namespace react;
-#endif
-
-namespace reanimated {
-
-#ifdef RCT_NEW_ARCH_ENABLED
-
-using UpdatePropsFunction =
-    std::function<void(jsi::Runtime &rt, const jsi::Value &operations)>;
-using ObtainPropFunction = std::function<jsi::Value(
-    jsi::Runtime &rt,
-    const jsi::Value &shadowNodeWrapper,
-    const jsi::Value &propName)>;
-using DispatchCommandFunction = std::function<void(
-    jsi::Runtime &rt,
-    const jsi::Value &shadowNodeValue,
-    const jsi::Value &commandNameValue,
-    const jsi::Value &argsValue)>;
-using MeasureFunction = std::function<
-    jsi::Value(jsi::Runtime &rt, const jsi::Value &shadowNodeValue)>;
-
-#else
-
-using UpdatePropsFunction =
-    std::function<void(jsi::Runtime &rt, const jsi::Value &operations)>;
-using ScrollToFunction = std::function<void(int, double, double, bool)>;
-using DispatchCommandFunction = std::function<void(
-    jsi::Runtime &rt,
-    const int viewTag,
-    const jsi::Value &commandNameValue,
-    const jsi::Value &argsValue)>;
-using MeasureFunction =
-    std::function<std::vector<std::pair<std::string, double>>(int)>;
-using ObtainPropFunction =
-    std::function<jsi::Value(jsi::Runtime &, const int, const jsi::Value &)>;
-
-#endif // RCT_NEW_ARCH_ENABLED
-
-using RequestRenderFunction =
-    std::function<void(std::function<void(const double)>)>;
-using GetAnimationTimestampFunction = std::function<double(void)>;
-
-using ProgressLayoutAnimationFunction =
-    std::function<void(jsi::Runtime &, int, jsi::Object, bool)>;
-using EndLayoutAnimationFunction = std::function<void(int, bool)>;
-
-using RegisterSensorFunction =
-    std::function<int(int, int, int, std::function<void(double[], int)>)>;
-using UnregisterSensorFunction = std::function<void(int)>;
-using SetGestureStateFunction = std::function<void(int, int)>;
-using ConfigurePropsFunction = std::function<void(
-    jsi::Runtime &rt,
-    const jsi::Value &uiProps,
-    const jsi::Value &nativeProps)>;
-using KeyboardEventSubscribeFunction =
-    std::function<int(std::function<void(int, int)>, bool, bool)>;
-using KeyboardEventUnsubscribeFunction = std::function<void(int)>;
-using MaybeFlushUIUpdatesQueueFunction = std::function<void()>;
-
-struct PlatformDepMethodsHolder {
-  RequestRenderFunction requestRender;
-#ifdef RCT_NEW_ARCH_ENABLED
-  // nothing
-#else
-  UpdatePropsFunction updatePropsFunction;
-  ScrollToFunction scrollToFunction;
-  DispatchCommandFunction dispatchCommandFunction;
-  MeasureFunction measureFunction;
-  ConfigurePropsFunction configurePropsFunction;
-  ObtainPropFunction obtainPropFunction;
-#endif
-  GetAnimationTimestampFunction getAnimationTimestamp;
-  ProgressLayoutAnimationFunction progressLayoutAnimation;
-  EndLayoutAnimationFunction endLayoutAnimation;
-  RegisterSensorFunction registerSensor;
-  UnregisterSensorFunction unregisterSensor;
-  SetGestureStateFunction setGestureStateFunction;
-  KeyboardEventSubscribeFunction subscribeForKeyboardEvents;
-  KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEvents;
-  MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueueFunction;
-};
-
-} // namespace reanimated
+#pragma once
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+#include <react/renderer/core/ReactPrimitives.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+using UpdatePropsFunction = std::function<void(jsi::Runtime &rt, const jsi::Value &operations)>;
+using ObtainPropFunction =
+    std::function<jsi::Value(jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper, const jsi::Value &propName)>;
+using DispatchCommandFunction = std::function<void(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeValue,
+    const jsi::Value &commandNameValue,
+    const jsi::Value &argsValue)>;
+using MeasureFunction = std::function<jsi::Value(jsi::Runtime &rt, const jsi::Value &shadowNodeValue)>;
+
+using RequestRenderFunction = std::function<void(std::function<void(const double)>)>;
+#ifdef ANDROID
+using SynchronouslyUpdateUIPropsFunction = std::function<void(const std::vector<int> &, const std::vector<double> &)>;
+#elif __APPLE__
+using SynchronouslyUpdateUIPropsFunction = std::function<void(const int, const folly::dynamic &)>;
+#endif // ANDROID
+//TODO
+using SynchronouslyUpdateUIPropsFunction = std::function<void(const int, const folly::dynamic &)>;
+using PreserveMountedTagsFunction = std::function<std::optional<std::unique_ptr<int[]>>(std::vector<int> &)>;
+using GetAnimationTimestampFunction = std::function<double(void)>;
+
+using ProgressLayoutAnimationFunction = std::function<void(jsi::Runtime &, int, jsi::Object)>;
+using EndLayoutAnimationFunction = std::function<void(int, bool)>;
+
+using RegisterSensorFunction = std::function<int(int, int, int, std::function<void(double[], int)>)>;
+using UnregisterSensorFunction = std::function<void(int)>;
+using SetGestureStateFunction = std::function<void(int, int)>;
+using KeyboardEventSubscribeFunction = std::function<int(std::function<void(int, int)>, bool, bool)>;
+using KeyboardEventUnsubscribeFunction = std::function<void(int)>;
+using MaybeFlushUIUpdatesQueueFunction = std::function<void()>;
+
+using ForceScreenSnapshotFunction = std::function<void(Tag tag)>;
+struct PlatformDepMethodsHolder {
+  RequestRenderFunction requestRender;
+#ifdef ANDROID
+  PreserveMountedTagsFunction filterUnmountedTagsFunction;
+#endif // ANDROID
+#ifdef __APPLE__
+  ForceScreenSnapshotFunction forceScreenSnapshotFunction;
+#endif
+  SynchronouslyUpdateUIPropsFunction synchronouslyUpdateUIPropsFunction;
+  GetAnimationTimestampFunction getAnimationTimestamp;
+  RegisterSensorFunction registerSensor;
+  UnregisterSensorFunction unregisterSensor;
+  SetGestureStateFunction setGestureStateFunction;
+  KeyboardEventSubscribeFunction subscribeForKeyboardEvents;
+  KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEvents;
+  MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueueFunction;
+};
+
+} // namespace reanimated