react-native-reanimated 2.4.1 → 2.5.0

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <react/jni/CxxModuleWrapper.h>
+#include <react/jni/JMessageQueueThread.h>
+#include <memory>
+#include "Scheduler.h"
+
+namespace reanimated {
+
+using namespace facebook;
+
+class AndroidScheduler : public jni::HybridClass<AndroidScheduler> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/Scheduler;";
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis);
+  static void registerNatives();
+
+  std::shared_ptr<Scheduler> getScheduler() {
+    return scheduler_;
+  }
+
+  void scheduleOnUI();
+
+ private:
+  friend HybridBase;
+
+  void triggerUI();
+
+  jni::global_ref<AndroidScheduler::javaobject> javaPart_;
+  std::shared_ptr<Scheduler> scheduler_;
+
+  explicit AndroidScheduler(
+      jni::alias_ref<AndroidScheduler::jhybridobject> jThis);
+};
+
+} // namespace reanimated

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <jsi/JSIDynamic.h>
+#include <jsi/jsi.h>
+#include <react/jni/CxxModuleWrapper.h>
+#include <react/jni/JMessageQueueThread.h>
+#include <react/jni/WritableNativeMap.h>
+#include <string>
+
+namespace reanimated {
+
+using namespace facebook::jni;
+using namespace facebook;
+using namespace react;
+
+struct JNIHelper {
+  struct PropsMap : jni::JavaClass<PropsMap, JMap<JString, JObject>> {
+    static constexpr auto kJavaDescriptor = "Ljava/util/HashMap;";
+
+    static local_ref<PropsMap> create();
+    void put(const std::string &key, jni::local_ref<JObject> object);
+  };
+
+  static jni::local_ref<PropsMap> ConvertToPropsMap(
+      jsi::Runtime &rt,
+      const jsi::Object &props);
+};
+
+}; // namespace reanimated

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

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include "JNIHelper.h"
+
+namespace reanimated {
+
+using namespace facebook::jni;
+using namespace facebook;
+
+class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/layoutReanimation/LayoutAnimations;";
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis);
+  static void registerNatives();
+
+  void startAnimationForTag(
+      int tag,
+      alias_ref<JString> type,
+      alias_ref<JMap<jstring, jstring>> values);
+  void removeConfigForTag(int tag);
+  bool isLayoutAnimationEnabled();
+
+  void setWeakUIRuntime(std::weak_ptr<jsi::Runtime> wrt);
+
+  void notifyAboutProgress(const jsi::Value &progress, int tag);
+  void notifyAboutEnd(int tag, int cancelled);
+
+ private:
+  friend HybridBase;
+  jni::global_ref<LayoutAnimations::javaobject> javaPart_;
+  std::weak_ptr<jsi::Runtime> weakUIRuntime;
+
+  explicit LayoutAnimations(
+      jni::alias_ref<LayoutAnimations::jhybridobject> jThis);
+};
+
+}; // namespace reanimated

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

@@ -0,0 +1,170 @@
+#pragma once
+
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <react/jni/CxxModuleWrapper.h>
+#include <react/jni/JMessageQueueThread.h>
+#include <react/jni/JavaScriptExecutorHolder.h>
+#include <react/jni/WritableNativeMap.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "AndroidScheduler.h"
+#include "JNIHelper.h"
+#include "LayoutAnimations.h"
+#include "NativeReanimatedModule.h"
+#include "Scheduler.h"
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace facebook::jni;
+
+class AnimationFrameCallback : public HybridClass<AnimationFrameCallback> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy$AnimationFrameCallback;";
+
+  void onAnimationFrame(double timestampMs) {
+    callback_(timestampMs);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod(
+            "onAnimationFrame", AnimationFrameCallback::onAnimationFrame),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit AnimationFrameCallback(std::function<void(double)> callback)
+      : callback_(std::move(callback)) {}
+
+  std::function<void(double)> callback_;
+};
+
+class EventHandler : public HybridClass<EventHandler> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy$EventHandler;";
+
+  void receiveEvent(
+      jni::alias_ref<JString> eventKey,
+      jni::alias_ref<react::WritableMap> event) {
+    std::string eventAsString = "{NativeMap:null}";
+    if (event != nullptr) {
+      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;
+      }
+    }
+    handler_(eventKey->toString(), eventAsString);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod("receiveEvent", EventHandler::receiveEvent),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit EventHandler(std::function<void(std::string, std::string)> handler)
+      : handler_(std::move(handler)) {}
+
+  std::function<void(std::string, std::string)> handler_;
+};
+
+class SensorSetter : public HybridClass<SensorSetter> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy$SensorSetter;";
+
+  void sensorSetter(jni::alias_ref<JArrayFloat> value) {
+    size_t size = value->size();
+    auto elements = value->getRegion(0, size);
+    double array[7];
+    for (int i = 0; i < size; i++) {
+      array[i] = elements[i];
+    }
+    callback_(array);
+  }
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({
+        makeNativeMethod("sensorSetter", SensorSetter::sensorSetter),
+    });
+  }
+
+ private:
+  friend HybridBase;
+
+  explicit SensorSetter(std::function<void(double[])> callback)
+      : callback_(std::move(callback)) {}
+
+  std::function<void(double[])> callback_;
+};
+
+class NativeProxy : public jni::HybridClass<NativeProxy> {
+ public:
+  static auto constexpr kJavaDescriptor =
+      "Lcom/swmansion/reanimated/NativeProxy;";
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+          jsCallInvokerHolder,
+      jni::alias_ref<AndroidScheduler::javaobject> scheduler,
+      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations);
+  static void registerNatives();
+
+ private:
+  friend HybridBase;
+  jni::global_ref<NativeProxy::javaobject> javaPart_;
+  jsi::Runtime *runtime_;
+  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
+  std::shared_ptr<NativeReanimatedModule> _nativeReanimatedModule;
+  std::shared_ptr<Scheduler> scheduler_;
+  jni::global_ref<LayoutAnimations::javaobject> layoutAnimations;
+
+  void installJSIBindings();
+  bool isAnyHandlerWaitingForEvent(std::string);
+  void requestRender(std::function<void(double)> onRender);
+  void registerEventHandler(
+      std::function<void(std::string, std::string)> handler);
+  void updateProps(jsi::Runtime &rt, int viewTag, const jsi::Object &props);
+  void scrollTo(int viewTag, double x, double y, bool animated);
+  void setGestureState(int handlerTag, int newState);
+  std::vector<std::pair<std::string, double>> measure(int viewTag);
+  int registerSensor(
+      int sensorType,
+      int interval,
+      std::function<void(double[])> setter);
+  void unregisterSensor(int sensorId);
+  void configureProps(
+      jsi::Runtime &rt,
+      const jsi::Value &uiProps,
+      const jsi::Value &nativeProps);
+
+  explicit NativeProxy(
+      jni::alias_ref<NativeProxy::jhybridobject> jThis,
+      jsi::Runtime *rt,
+      std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<Scheduler> scheduler,
+      jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations);
+};
+
+} // namespace reanimated

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

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ */
+
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace facebook {
+namespace react {
+
+/**
+ * For now, support the same set of return types as existing impl.
+ * This can be improved to support richer typed objects.
+ */
+enum TurboModuleMethodValueKind {
+  VoidKind,
+  BooleanKind,
+  NumberKind,
+  StringKind,
+  ObjectKind,
+  ArrayKind,
+  FunctionKind,
+  PromiseKind,
+};
+
+/**
+ * Base HostObject class for every module to be exposed to JS
+ */
+class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
+ public:
+  TurboModule(const std::string &name, std::shared_ptr<CallInvoker> jsInvoker);
+  virtual ~TurboModule();
+
+  facebook::jsi::Value get(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::PropNameID &propName) override;
+
+  const std::string name_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+
+ protected:
+  struct MethodMetadata {
+    size_t argCount;
+    facebook::jsi::Value (*invoker)(
+        facebook::jsi::Runtime &rt,
+        TurboModule &turboModule,
+        const facebook::jsi::Value *args,
+        size_t count);
+  };
+
+  std::unordered_map<std::string, MethodMetadata> methodMap_;
+};
+
+/**
+ * An app/platform-specific provider function to get an instance of a module
+ * given a name.
+ */
+using TurboModuleProviderFunctionType =
+    std::function<std::shared_ptr<TurboModule>(const std::string &name)>;
+
+} // namespace react
+} // namespace facebook

package/android/src/main/java/com/facebook/react/uimanager/UIManagerReanimatedHelper.java

@@ -0,0 +1,15 @@
+package com.facebook.react.uimanager;
+
+/**
+ * This class provides a way to workaround limited visibility of
+ * UIViewOperationQueue#getUIViewOperationQueue. We rely on accessing that method to check if
+ * operation queue is empty or not. This in turn indicates if we are in a middle of processing batch
+ * of operations from JS. In such a case we can rely on the enqueued update operations to be flushed
+ * onto the shadow view hierarchy. Otherwise we want to trigger "dispatchViewUpdates" and enforce
+ * flush immediately.
+ */
+public class UIManagerReanimatedHelper {
+  public static boolean isOperationQueueEmpty(UIImplementation uiImplementation) {
+    return uiImplementation.getUIViewOperationQueue().isEmpty();
+  }
+}

package/android/src/main/java/com/swmansion/common/GestureHandlerStateManager.java

@@ -0,0 +1,5 @@
+package com.swmansion.common;
+
+public interface GestureHandlerStateManager {
+  void setGestureHandlerState(int handlerTag, int newState);
+}

package/android/src/main/java/com/swmansion/reanimated/AndroidErrorHandler.java

@@ -0,0 +1,8 @@
+package com.swmansion.reanimated;
+
+public class AndroidErrorHandler {
+
+  public static void raise(String message) {
+    throw new RuntimeException(message);
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/CopiedEvent.java

@@ -0,0 +1,43 @@
+package com.swmansion.reanimated;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+public class CopiedEvent {
+  private int targetTag;
+  private String eventName;
+  private WritableMap payload;
+
+  CopiedEvent(Event event) {
+    event.dispatch(
+        new RCTEventEmitter() {
+          @Override
+          public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+            CopiedEvent.this.targetTag = targetTag;
+            CopiedEvent.this.eventName = eventName;
+            CopiedEvent.this.payload = event.copy();
+          }
+
+          @Override
+          public void receiveTouches(
+              String eventName, WritableArray touches, WritableArray changedIndices) {
+            // noop
+          }
+        });
+  }
+
+  public int getTargetTag() {
+    return targetTag;
+  }
+
+  public String getEventName() {
+    return eventName;
+  }
+
+  public WritableMap getPayload() {
+    return payload;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/MapUtils.java

@@ -0,0 +1,26 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.JSApplicationCausedNativeException;
+import com.facebook.react.bridge.NoSuchKeyException;
+import com.facebook.react.bridge.ReadableMap;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MapUtils {
+  public static int getInt(ReadableMap map, @Nonnull String name, String errorMsg) {
+    try {
+      return map.getInt(name);
+    } catch (NoSuchKeyException e) {
+      throw new JSApplicationCausedNativeException(errorMsg);
+    }
+  }
+
+  @Nullable
+  public static String getString(ReadableMap map, @Nonnull String name, String errorMsg) {
+    try {
+      return map.getString(name);
+    } catch (NoSuchKeyException e) {
+      throw new JSApplicationCausedNativeException(errorMsg);
+    }
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/NativeMethodsHelper.java

@@ -0,0 +1,117 @@
+package com.swmansion.reanimated;
+
+import android.graphics.Matrix;
+import android.graphics.RectF;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewParent;
+import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.RootViewUtil;
+import com.facebook.react.views.scroll.ReactHorizontalScrollView;
+import com.facebook.react.views.scroll.ReactScrollView;
+import com.facebook.react.views.swiperefresh.ReactSwipeRefreshLayout;
+
+public class NativeMethodsHelper {
+
+  public static float[] measure(View view) {
+    View rootView = (View) RootViewUtil.getRootView(view);
+    if (rootView == null || view == null) {
+      float result[] = new float[6];
+      result[0] = -1234567;
+      return result;
+    }
+
+    int buffer[] = new int[4];
+    computeBoundingBox(rootView, buffer);
+    int rootX = buffer[0];
+    int rootY = buffer[1];
+    computeBoundingBox(view, buffer);
+    buffer[0] -= rootX;
+    buffer[1] -= rootY;
+
+    float result[] = new float[6];
+    result[0] = result[1] = 0;
+    for (int i = 2; i < 6; ++i) result[i] = PixelUtil.toDIPFromPixel(buffer[i - 2]);
+
+    return result;
+  }
+
+  public static void scrollTo(View view, double argX, double argY, boolean animated) {
+    int x = Math.round(PixelUtil.toPixelFromDIP(argX));
+    int y = Math.round(PixelUtil.toPixelFromDIP(argY));
+    boolean horizontal = false;
+
+    if (view instanceof ReactHorizontalScrollView) {
+      horizontal = true;
+    } else {
+      if (view instanceof ReactSwipeRefreshLayout) {
+        view = findScrollView((ReactSwipeRefreshLayout) view);
+      }
+      if (!(view instanceof ReactScrollView)) {
+        Log.w(
+            "REANIMATED",
+            "NativeMethodsHelper: Unhandled scroll view type - allowed only {ReactScrollView, ReactHorizontalScrollView}");
+        return;
+      }
+    }
+
+    if (animated) {
+      if (horizontal) {
+        ((ReactHorizontalScrollView) view).smoothScrollTo((int) x, (int) y);
+      } else {
+        ((ReactScrollView) view).smoothScrollTo((int) x, (int) y);
+      }
+    } else {
+      if (horizontal) {
+        ((ReactHorizontalScrollView) view).scrollTo((int) x, (int) y);
+      } else {
+        ((ReactScrollView) view).scrollTo((int) x, (int) y);
+      }
+    }
+  }
+
+  private static ReactScrollView findScrollView(ReactSwipeRefreshLayout view) {
+    for (int i = 0; i < view.getChildCount(); i++) {
+      if (view.getChildAt(i) instanceof ReactScrollView) {
+        return (ReactScrollView) view.getChildAt(i);
+      }
+    }
+    return null;
+  }
+
+  private static void computeBoundingBox(View view, int[] outputBuffer) {
+    RectF boundingBox = new RectF();
+    boundingBox.set(0, 0, view.getWidth(), view.getHeight());
+    mapRectFromViewToWindowCoords(view, boundingBox);
+
+    outputBuffer[0] = Math.round(boundingBox.left);
+    outputBuffer[1] = Math.round(boundingBox.top);
+    outputBuffer[2] = Math.round(boundingBox.right - boundingBox.left);
+    outputBuffer[3] = Math.round(boundingBox.bottom - boundingBox.top);
+  }
+
+  private static void mapRectFromViewToWindowCoords(View view, RectF rect) {
+    Matrix matrix = view.getMatrix();
+    if (!matrix.isIdentity()) {
+      matrix.mapRect(rect);
+    }
+
+    rect.offset(view.getLeft(), view.getTop());
+
+    ViewParent parent = view.getParent();
+    while (parent instanceof View) {
+      View parentView = (View) parent;
+
+      rect.offset(-parentView.getScrollX(), -parentView.getScrollY());
+
+      matrix = parentView.getMatrix();
+      if (!matrix.isIdentity()) {
+        matrix.mapRect(rect);
+      }
+
+      rect.offset(parentView.getLeft(), parentView.getTop());
+
+      parent = parentView.getParent();
+    }
+  }
+}