react-native-reanimated 2.4.1 → 2.7.0

package/android/src/main/cpp/AndroidLogger.cpp

@@ -0,0 +1,27 @@
+#include "AndroidLogger.h"
+#include <android/log.h>
+#include "Logger.h"
+#define APPNAME "NATIVE_REANIMATED"
+
+namespace reanimated {
+
+std::unique_ptr<LoggerInterface> Logger::instance =
+    std::make_unique<AndroidLogger>();
+
+void AndroidLogger::log(const char *str) {
+  __android_log_print(ANDROID_LOG_VERBOSE, APPNAME, "%s", str);
+}
+
+void AndroidLogger::log(double d) {
+  __android_log_print(ANDROID_LOG_VERBOSE, APPNAME, "%f", d);
+}
+
+void AndroidLogger::log(int i) {
+  __android_log_print(ANDROID_LOG_VERBOSE, APPNAME, "%d", i);
+}
+
+void AndroidLogger::log(bool b) {
+  __android_log_print(ANDROID_LOG_VERBOSE, APPNAME, "%s", b ? "true" : "false");
+}
+
+} // namespace reanimated

package/android/src/main/cpp/AndroidScheduler.cpp

@@ -0,0 +1,59 @@
+#include "AndroidScheduler.h"
+#include <android/log.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace react;
+
+class SchedulerWrapper : public Scheduler {
+ private:
+  jni::global_ref<AndroidScheduler::javaobject> scheduler_;
+
+ public:
+  explicit SchedulerWrapper(
+      jni::global_ref<AndroidScheduler::javaobject> scheduler)
+      : scheduler_(scheduler) {}
+
+  void scheduleOnUI(std::function<void()> job) override {
+    Scheduler::scheduleOnUI(job);
+    if (!scheduledOnUI) {
+      scheduledOnUI = true;
+      scheduler_->cthis()->scheduleOnUI();
+    }
+  }
+
+  ~SchedulerWrapper() {}
+};
+
+AndroidScheduler::AndroidScheduler(
+    jni::alias_ref<AndroidScheduler::javaobject> jThis)
+    : javaPart_(jni::make_global(jThis)),
+      scheduler_(new SchedulerWrapper(jni::make_global(jThis))) {}
+
+jni::local_ref<AndroidScheduler::jhybriddata> AndroidScheduler::initHybrid(
+    jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void AndroidScheduler::triggerUI() {
+  scheduler_->triggerUI();
+}
+
+void AndroidScheduler::scheduleOnUI() {
+  static auto method = javaPart_->getClass()->getMethod<void()>("scheduleOnUI");
+  method(javaPart_.get());
+}
+
+void AndroidScheduler::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", AndroidScheduler::initHybrid),
+      makeNativeMethod("triggerUI", AndroidScheduler::triggerUI),
+  });
+}
+
+} // namespace reanimated

package/android/src/main/cpp/JNIHelper.cpp

@@ -0,0 +1,59 @@
+#include "JNIHelper.h"
+
+namespace reanimated {
+
+using namespace facebook::jni;
+using namespace facebook;
+using namespace react;
+
+local_ref<JNIHelper::PropsMap> JNIHelper::PropsMap::create() {
+  return newInstance();
+}
+
+void JNIHelper::PropsMap::put(
+    const std::string &key,
+    jni::local_ref<JObject> object) {
+  static auto method =
+      getClass()
+          ->getMethod<jobject(
+              jni::local_ref<JObject>, jni::local_ref<JObject>)>("put");
+  method(self(), jni::make_jstring(key), object);
+}
+
+jni::local_ref<JNIHelper::PropsMap> JNIHelper::ConvertToPropsMap(
+    jsi::Runtime &rt,
+    const jsi::Object &props) {
+  auto map = PropsMap::create();
+
+  auto propNames = props.getPropertyNames(rt);
+  for (size_t i = 0, size = propNames.size(rt); i < size; i++) {
+    auto jsiKey = propNames.getValueAtIndex(rt, i).asString(rt);
+    auto value = props.getProperty(rt, jsiKey);
+    auto key = jsiKey.utf8(rt);
+    if (value.isUndefined() || value.isNull()) {
+      map->put(key, nullptr);
+    } else if (value.isBool()) {
+      map->put(key, JBoolean::valueOf(value.getBool()));
+    } else if (value.isNumber()) {
+      map->put(key, jni::autobox(value.asNumber()));
+    } else if (value.isString()) {
+      map->put(key, jni::make_jstring(value.asString(rt).utf8(rt)));
+    } else if (value.isObject()) {
+      if (value.asObject(rt).isArray(rt)) {
+        map->put(
+            key,
+            ReadableNativeArray::newObjectCxxArgs(
+                jsi::dynamicFromValue(rt, value)));
+      } else {
+        map->put(
+            key,
+            ReadableNativeMap::newObjectCxxArgs(
+                jsi::dynamicFromValue(rt, value)));
+      }
+    }
+  }
+
+  return map;
+}
+
+}; // namespace reanimated

package/android/src/main/cpp/LayoutAnimations.cpp

@@ -0,0 +1,103 @@
+#include "LayoutAnimations.h"
+#include "FeaturesConfig.h"
+#include "Logger.h"
+
+namespace reanimated {
+
+LayoutAnimations::LayoutAnimations(
+    jni::alias_ref<LayoutAnimations::javaobject> jThis)
+    : javaPart_(jni::make_global(jThis)) {}
+
+jni::local_ref<LayoutAnimations::jhybriddata> LayoutAnimations::initHybrid(
+    jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void LayoutAnimations::setWeakUIRuntime(std::weak_ptr<jsi::Runtime> wrt) {
+  this->weakUIRuntime = wrt;
+}
+
+void LayoutAnimations::startAnimationForTag(
+    int tag,
+    alias_ref<JString> type,
+    alias_ref<JMap<jstring, jstring>> values) {
+  if (auto rt = this->weakUIRuntime.lock()) {
+    jsi::Value layoutAnimationRepositoryAsValue =
+        rt->global()
+            .getPropertyAsObject(*rt, "global")
+            .getProperty(*rt, "LayoutAnimationRepository");
+    if (!layoutAnimationRepositoryAsValue.isUndefined()) {
+      jsi::Function startAnimationForTag =
+          layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(
+              *rt, "startAnimationForTag");
+      jsi::Object target(*rt);
+
+      for (const auto &entry : *values) {
+        target.setProperty(
+            *rt,
+            entry.first->toStdString().c_str(),
+            std::stof(entry.second->toStdString()));
+      }
+      startAnimationForTag.call(
+          *rt,
+          jsi::Value(tag),
+          jsi::String::createFromUtf8(*rt, type->toStdString()),
+          target);
+    }
+  }
+}
+
+void LayoutAnimations::removeConfigForTag(int tag) {
+  if (auto rt = this->weakUIRuntime.lock()) {
+    jsi::Value layoutAnimationRepositoryAsValue =
+        rt->global()
+            .getPropertyAsObject(*rt, "global")
+            .getProperty(*rt, "LayoutAnimationRepository");
+    if (!layoutAnimationRepositoryAsValue.isUndefined()) {
+      jsi::Function removeConfig =
+          layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(
+              *rt, "removeConfig");
+      removeConfig.call(*rt, jsi::Value(tag));
+    }
+  }
+}
+
+void LayoutAnimations::notifyAboutProgress(
+    const jsi::Value &progress,
+    int tag) {
+  if (auto rt = this->weakUIRuntime.lock()) {
+    static const auto method =
+        javaPart_->getClass()
+            ->getMethod<void(JMap<JString, JObject>::javaobject, int)>(
+                "notifyAboutProgress");
+    method(
+        javaPart_.get(),
+        JNIHelper::ConvertToPropsMap(*rt, progress.asObject(*rt)).get(),
+        tag);
+  }
+}
+
+void LayoutAnimations::notifyAboutEnd(int tag, int cancelled) {
+  static const auto method =
+      javaPart_->getClass()->getMethod<void(int, int)>("notifyAboutEnd");
+  method(javaPart_.get(), tag, cancelled);
+}
+
+bool LayoutAnimations::isLayoutAnimationEnabled() {
+  return FeaturesConfig::isLayoutAnimationEnabled();
+}
+
+void LayoutAnimations::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", LayoutAnimations::initHybrid),
+      makeNativeMethod(
+          "startAnimationForTag", LayoutAnimations::startAnimationForTag),
+      makeNativeMethod(
+          "removeConfigForTag", LayoutAnimations::removeConfigForTag),
+      makeNativeMethod(
+          "isLayoutAnimationEnabled",
+          LayoutAnimations::isLayoutAnimationEnabled),
+  });
+}
+
+}; // namespace reanimated

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

@@ -0,0 +1,327 @@
+#include <fbjni/fbjni.h>
+#include <jsi/JSIDynamic.h>
+#include <jsi/jsi.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <react/jni/ReadableNativeMap.h>
+
+#include <memory>
+#include <string>
+
+#if FOR_HERMES
+#include <hermes/hermes.h>
+#else
+#include <jsi/JSCRuntime.h>
+#endif
+
+#include <android/log.h>
+#include "AndroidErrorHandler.h"
+#include "AndroidScheduler.h"
+#include "LayoutAnimationsProxy.h"
+#include "NativeProxy.h"
+#include "PlatformDepMethodsHolder.h"
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace react;
+
+NativeProxy::NativeProxy(
+    jni::alias_ref<NativeProxy::javaobject> jThis,
+    jsi::Runtime *rt,
+    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<Scheduler> scheduler,
+    jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations)
+    : javaPart_(jni::make_global(jThis)),
+      runtime_(rt),
+      jsCallInvoker_(jsCallInvoker),
+      scheduler_(scheduler),
+      layoutAnimations(std::move(_layoutAnimations)) {}
+
+jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
+    jni::alias_ref<jhybridobject> jThis,
+    jlong jsContext,
+    jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+        jsCallInvokerHolder,
+    jni::alias_ref<AndroidScheduler::javaobject> androidScheduler,
+    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations) {
+  auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+  auto scheduler = androidScheduler->cthis()->getScheduler();
+  scheduler->setJSCallInvoker(jsCallInvoker);
+  return makeCxxInstance(
+      jThis,
+      (jsi::Runtime *)jsContext,
+      jsCallInvoker,
+      scheduler,
+      make_global(layoutAnimations));
+}
+
+void NativeProxy::installJSIBindings() {
+  auto propUpdater = [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 getCurrentTime = [this]() {
+    auto method =
+        javaPart_->getClass()->getMethod<local_ref<JString>()>("getUptime");
+    local_ref<JString> output = method(javaPart_.get());
+    return static_cast<double>(
+        std::strtoll(output->toStdString().c_str(), NULL, 10));
+  };
+
+  auto requestRender = [this, getCurrentTime](
+                           std::function<void(double)> onRender,
+                           jsi::Runtime &rt) {
+    // doNoUse -> NodesManager passes here a timestamp from choreographer which
+    // is useless for us as we use diffrent timer to better handle events. The
+    // lambda is translated to NodeManager.OnAnimationFrame and treated just
+    // like reanimated 1 frame callbacks which make use of the timestamp.
+    auto wrappedOnRender = [getCurrentTime, &rt, onRender](double doNotUse) {
+      jsi::Object global = rt.global();
+      jsi::String frameTimestampName =
+          jsi::String::createFromAscii(rt, "_frameTimestamp");
+      double frameTimestamp = getCurrentTime();
+      global.setProperty(rt, frameTimestampName, frameTimestamp);
+      onRender(frameTimestamp);
+      global.setProperty(rt, frameTimestampName, jsi::Value::undefined());
+    };
+    this->requestRender(std::move(wrappedOnRender));
+  };
+
+  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 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 registerSensorFunction =
+      [this](int sensorType, int interval, std::function<void(double[])> 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);
+  };
+#if FOR_HERMES
+  auto config =
+      ::hermes::vm::RuntimeConfig::Builder().withEnableSampleProfiling(false);
+  std::shared_ptr<jsi::Runtime> animatedRuntime =
+      facebook::hermes::makeHermesRuntime(config.build());
+#else
+  std::shared_ptr<jsi::Runtime> animatedRuntime =
+      facebook::jsc::makeJSCRuntime();
+#endif
+  runtime_->global().setProperty(
+      *runtime_,
+      "_WORKLET_RUNTIME",
+      static_cast<double>(
+          reinterpret_cast<std::uintptr_t>(animatedRuntime.get())));
+
+  std::shared_ptr<ErrorHandler> errorHandler =
+      std::make_shared<AndroidErrorHandler>(scheduler_);
+
+  // Layout Animations Start
+
+  auto notifyAboutProgress = [=](int tag, jsi::Value progress) {
+    this->layoutAnimations->cthis()->notifyAboutProgress(progress, tag);
+  };
+
+  auto notifyAboutEnd = [=](int tag, bool isCancelled) {
+    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);
+  std::weak_ptr<jsi::Runtime> wrt = animatedRuntime;
+  layoutAnimations->cthis()->setWeakUIRuntime(wrt);
+
+  // Layout Animations End
+
+  PlatformDepMethodsHolder platformDepMethodsHolder = {
+      requestRender,
+      propUpdater,
+      scrollToFunction,
+      measuringFunction,
+      getCurrentTime,
+      registerSensorFunction,
+      unregisterSensorFunction,
+      setGestureStateFunction,
+      configurePropsFunction};
+
+  auto module = std::make_shared<NativeReanimatedModule>(
+      jsCallInvoker_,
+      scheduler_,
+      animatedRuntime,
+      errorHandler,
+      propObtainer,
+      layoutAnimationsProxy,
+      platformDepMethodsHolder);
+
+  _nativeReanimatedModule = module;
+
+  this->registerEventHandler([module, getCurrentTime](
+                                 std::string eventName,
+                                 std::string eventAsString) {
+    jsi::Object global = module->runtime->global();
+    jsi::String eventTimestampName =
+        jsi::String::createFromAscii(*module->runtime, "_eventTimestamp");
+    global.setProperty(*module->runtime, eventTimestampName, getCurrentTime());
+    module->onEvent(eventName, eventAsString);
+    global.setProperty(
+        *module->runtime, eventTimestampName, jsi::Value::undefined());
+  });
+
+  runtime_->global().setProperty(
+      *runtime_,
+      jsi::PropNameID::forAscii(*runtime_, "__reanimatedModuleProxy"),
+      jsi::Object::createFromHostObject(*runtime_, module));
+}
+
+bool NativeProxy::isAnyHandlerWaitingForEvent(std::string s) {
+  return _nativeReanimatedModule->isAnyHandlerWaitingForEvent(s);
+}
+
+void NativeProxy::registerNatives() {
+  registerHybrid(
+      {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
+       makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
+       makeNativeMethod(
+           "isAnyHandlerWaitingForEvent",
+           NativeProxy::isAnyHandlerWaitingForEvent)});
+}
+
+void NativeProxy::requestRender(std::function<void(double)> onRender) {
+  static auto method =
+      javaPart_->getClass()
+          ->getMethod<void(AnimationFrameCallback::javaobject)>(
+              "requestRender");
+  method(
+      javaPart_.get(),
+      AnimationFrameCallback::newObjectCxxArgs(std::move(onRender)).get());
+}
+
+void NativeProxy::registerEventHandler(
+    std::function<void(std::string, std::string)> handler) {
+  static auto method =
+      javaPart_->getClass()->getMethod<void(EventHandler::javaobject)>(
+          "registerEventHandler");
+  method(
+      javaPart_.get(),
+      EventHandler::newObjectCxxArgs(std::move(handler)).get());
+}
+
+void NativeProxy::updateProps(
+    jsi::Runtime &rt,
+    int viewTag,
+    const jsi::Object &props) {
+  auto method = javaPart_->getClass()
+                    ->getMethod<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");
+  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");
+  local_ref<JArrayFloat> output = method(javaPart_.get(), viewTag);
+  size_t size = output->size();
+  auto elements = output->getRegion(0, size);
+  std::vector<std::pair<std::string, double>> result;
+
+  result.push_back({"x", elements[0]});
+  result.push_back({"y", elements[1]});
+
+  result.push_back({"pageX", elements[2]});
+  result.push_back({"pageY", elements[3]});
+
+  result.push_back({"width", elements[4]});
+  result.push_back({"height", elements[5]});
+
+  return result;
+}
+
+int NativeProxy::registerSensor(
+    int sensorType,
+    int interval,
+    std::function<void(double[])> setter) {
+  static auto method =
+      javaPart_->getClass()->getMethod<int(int, int, SensorSetter::javaobject)>(
+          "registerSensor");
+  return method(
+      javaPart_.get(),
+      sensorType,
+      interval,
+      SensorSetter::newObjectCxxArgs(std::move(setter)).get());
+}
+void NativeProxy::unregisterSensor(int sensorId) {
+  auto method = javaPart_->getClass()->getMethod<void(int)>("unregisterSensor");
+  method(javaPart_.get(), sensorId);
+}
+
+void NativeProxy::setGestureState(int handlerTag, int newState) {
+  auto method =
+      javaPart_->getClass()->getMethod<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(
+          std::move(jsi::dynamicFromValue(rt, uiProps)))
+          .get(),
+      ReadableNativeArray::newObjectCxxArgs(
+          std::move(jsi::dynamicFromValue(rt, nativeProps)))
+          .get());
+}
+
+} // namespace reanimated

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

@@ -0,0 +1,17 @@
+#include <fbjni/fbjni.h>
+
+#include "AndroidScheduler.h"
+#include "LayoutAnimations.h"
+#include "Logger.h"
+#include "NativeProxy.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    reanimated::NativeProxy::registerNatives();
+    reanimated::AnimationFrameCallback::registerNatives();
+    reanimated::EventHandler::registerNatives();
+    reanimated::AndroidScheduler::registerNatives();
+    reanimated::LayoutAnimations::registerNatives();
+    reanimated::SensorSetter::registerNatives();
+  });
+}

package/android/src/main/cpp/TurboModule.cpp

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "TurboModule.h"
+
+using namespace facebook;
+
+namespace facebook {
+namespace react {
+
+TurboModule::TurboModule(
+    const std::string &name,
+    std::shared_ptr<CallInvoker> jsInvoker)
+    : name_(name), jsInvoker_(jsInvoker) {}
+
+TurboModule::~TurboModule() {}
+
+jsi::Value TurboModule::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &propName) {
+  std::string propNameUtf8 = propName.utf8(runtime);
+  auto p = methodMap_.find(propNameUtf8);
+  if (p == methodMap_.end()) {
+    // Method was not found, let JS decide what to do.
+    return jsi::Value::undefined();
+  }
+  MethodMetadata meta = p->second;
+  return jsi::Function::createFromHostFunction(
+      runtime,
+      propName,
+      meta.argCount,
+      [this, meta](
+          facebook::jsi::Runtime &rt,
+          const facebook::jsi::Value &thisVal,
+          const facebook::jsi::Value *args,
+          size_t count) { return meta.invoker(rt, *this, args, count); });
+}
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <memory>
+#include <string>
+#include "AndroidScheduler.h"
+#include "ErrorHandler.h"
+#include "Logger.h"
+#include "Scheduler.h"
+
+namespace reanimated {
+
+class AndroidErrorHandler : public JavaClass<AndroidErrorHandler>,
+                            public ErrorHandler {
+  std::shared_ptr<ErrorWrapper> error;
+  std::shared_ptr<Scheduler> scheduler;
+  void raiseSpec() override;
+
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/AndroidErrorHandler;";
+  explicit AndroidErrorHandler(std::shared_ptr<Scheduler> scheduler);
+  std::shared_ptr<Scheduler> getScheduler() override;
+  std::shared_ptr<ErrorWrapper> getError() override;
+  void setError(std::string message) override;
+  virtual ~AndroidErrorHandler() {}
+};
+
+} // namespace reanimated

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

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "LoggerInterface.h"
+
+namespace reanimated {
+
+class AndroidLogger : public LoggerInterface {
+ public:
+  void log(const char *str) override;
+  void log(double d) override;
+  void log(int i) override;
+  void log(bool b) override;
+  virtual ~AndroidLogger() {}
+};
+
+} // namespace reanimated