react-native-reanimated 2.3.3 → 2.5.0

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/ReanimatedUIManager.java

@@ -0,0 +1,292 @@
+package com.facebook.react.uimanager;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import java.util.List;
+
+class ReaUiImplementationProvider extends UIImplementationProvider {
+
+  @Override
+  UIImplementation createUIImplementation(
+      ReactApplicationContext reactContext,
+      ViewManagerRegistry viewManagerRegistry,
+      EventDispatcher eventDispatcher,
+      int minTimeLeftInFrameForNonBatchedOperationMs) {
+    return new ReanimatedUIImplementation(
+        reactContext,
+        viewManagerRegistry,
+        eventDispatcher,
+        minTimeLeftInFrameForNonBatchedOperationMs);
+  }
+}
+
+@ReactModule(name = UIManagerModule.NAME)
+public class ReanimatedUIManager extends UIManagerModule {
+
+  public ReanimatedUIManager(
+      ReactApplicationContext reactContext,
+      List<ViewManager> viewManagersList,
+      int minTimeLeftInFrameForNonBatchedOperationMs) {
+    super(
+        reactContext,
+        viewManagersList,
+        new ReaUiImplementationProvider(),
+        minTimeLeftInFrameForNonBatchedOperationMs);
+  }
+
+  public void onBatchComplete() {
+    super.onBatchComplete();
+  }
+
+  @Override
+  public boolean canOverrideExistingModule() {
+    return true;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public @Nullable WritableMap getConstantsForViewManager(@Nullable String viewManagerName) {
+    return super.getConstantsForViewManager(viewManagerName);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap getDefaultEventTypes() {
+    return super.getDefaultEventTypes();
+  }
+
+  /** Unregisters a new root view. */
+  @ReactMethod
+  public void removeRootView(int rootViewTag) {
+    super.removeRootView(rootViewTag);
+  }
+
+  @ReactMethod
+  public void createView(int tag, String className, int rootViewTag, ReadableMap props) {
+    super.createView(tag, className, rootViewTag, props);
+  }
+
+  @ReactMethod
+  public void updateView(final int tag, final String className, final ReadableMap props) {
+    super.updateView(tag, className, props);
+  }
+
+  /**
+   * Interface for adding/removing/moving views within a parent view from JS.
+   *
+   * @param viewTag the view tag of the parent view
+   * @param moveFrom a list of indices in the parent view to move views from
+   * @param moveTo parallel to moveFrom, a list of indices in the parent view to move views to
+   * @param addChildTags a list of tags of views to add to the parent
+   * @param addAtIndices parallel to addChildTags, a list of indices to insert those children at
+   * @param removeFrom a list of indices of views to permanently remove. The memory for the
+   *     corresponding views and data structures should be reclaimed.
+   */
+  @ReactMethod
+  public void manageChildren(
+      int viewTag,
+      @Nullable ReadableArray moveFrom,
+      @Nullable ReadableArray moveTo,
+      @Nullable ReadableArray addChildTags,
+      @Nullable ReadableArray addAtIndices,
+      @Nullable ReadableArray removeFrom) {
+    super.manageChildren(viewTag, moveFrom, moveTo, addChildTags, addAtIndices, removeFrom);
+  }
+
+  /**
+   * Interface for fast tracking the initial adding of views. Children view tags are assumed to be
+   * in order
+   *
+   * @param viewTag the view tag of the parent view
+   * @param childrenTags An array of tags to add to the parent in order
+   */
+  @ReactMethod
+  public void setChildren(int viewTag, ReadableArray childrenTags) {
+    super.setChildren(viewTag, childrenTags);
+  }
+
+  /**
+   * Replaces the View specified by oldTag with the View specified by newTag within oldTag's parent.
+   * This resolves to a simple {@link #manageChildren} call, but React doesn't have enough info in
+   * JS to formulate it itself.
+   *
+   * @deprecated This method will not be available in Fabric UIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void replaceExistingNonRootView(int oldTag, int newTag) {
+    super.replaceExistingNonRootView(oldTag, newTag);
+  }
+
+  /**
+   * Method which takes a container tag and then releases all subviews for that container upon
+   * receipt.
+   *
+   * @param containerTag the tag of the container for which the subviews must be removed
+   * @deprecated This method will not be available in Fabric UIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void removeSubviewsFromContainerWithID(int containerTag) {
+    super.removeSubviewsFromContainerWithID(containerTag);
+  }
+
+  /**
+   * Determines the location on screen, width, and height of the given view and returns the values
+   * via an async callback.
+   */
+  @ReactMethod
+  public void measure(int reactTag, Callback callback) {
+    super.measure(reactTag, callback);
+  }
+
+  /**
+   * Determines the location on screen, width, and height of the given view relative to the device
+   * screen and returns the values via an async callback. This is the absolute position including
+   * things like the status bar
+   */
+  @ReactMethod
+  public void measureInWindow(int reactTag, Callback callback) {
+    super.measureInWindow(reactTag, callback);
+  }
+
+  /**
+   * Measures the view specified by tag relative to the given ancestorTag. This means that the
+   * returned x, y are relative to the origin x, y of the ancestor view. Results are stored in the
+   * given outputBuffer. We allow ancestor view and measured view to be the same, in which case the
+   * position always will be (0, 0) and method will only measure the view dimensions.
+   *
+   * <p>NB: Unlike {@link #measure}, this will measure relative to the view layout, not the visible
+   * window which can cause unexpected results when measuring relative to things like ScrollViews
+   * that can have offset content on the screen.
+   */
+  @ReactMethod
+  public void measureLayout(
+      int tag, int ancestorTag, Callback errorCallback, Callback successCallback) {
+    super.measureLayout(tag, ancestorTag, errorCallback, successCallback);
+  }
+
+  /**
+   * Like {@link #measure} and {@link #measureLayout} but measures relative to the immediate parent.
+   *
+   * <p>NB: Unlike {@link #measure}, this will measure relative to the view layout, not the visible
+   * window which can cause unexpected results when measuring relative to things like ScrollViews
+   * that can have offset content on the screen.
+   *
+   * @deprecated this method will not be available in FabricUIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void measureLayoutRelativeToParent(
+      int tag, Callback errorCallback, Callback successCallback) {
+    super.measureLayoutRelativeToParent(tag, errorCallback, successCallback);
+  }
+
+  /**
+   * Find the touch target child native view in the supplied root view hierarchy, given a react
+   * target location.
+   *
+   * <p>This method is currently used only by Element Inspector DevTool.
+   *
+   * @param reactTag the tag of the root view to traverse
+   * @param point an array containing both X and Y target location
+   * @param callback will be called if with the identified child view react ID, and measurement
+   *     info. If no view was found, callback will be invoked with no data.
+   */
+  @ReactMethod
+  public void findSubviewIn(
+      final int reactTag, final ReadableArray point, final Callback callback) {
+    super.findSubviewIn(reactTag, point, callback);
+  }
+
+  /**
+   * Check if the first shadow node is the descendant of the second shadow node
+   *
+   * @deprecated this method will not be available in FabricUIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void viewIsDescendantOf(
+      final int reactTag, final int ancestorReactTag, final Callback callback) {
+    super.viewIsDescendantOf(reactTag, ancestorReactTag, callback);
+  }
+
+  @ReactMethod
+  public void setJSResponder(int reactTag, boolean blockNativeResponder) {
+    super.setJSResponder(reactTag, blockNativeResponder);
+  }
+
+  @ReactMethod
+  public void clearJSResponder() {
+    super.clearJSResponder();
+  }
+
+  @ReactMethod
+  public void dispatchViewManagerCommand(
+      int reactTag, Dynamic commandId, @Nullable ReadableArray commandArgs) {
+    super.dispatchViewManagerCommand(reactTag, commandId, commandArgs);
+  }
+
+  /**
+   * Show a PopupMenu.
+   *
+   * @param reactTag the tag of the anchor view (the PopupMenu is displayed next to this view); this
+   *     needs to be the tag of a native view (shadow views can not be anchors)
+   * @param items the menu items as an array of strings
+   * @param error will be called if there is an error displaying the menu
+   * @param success will be called with the position of the selected item as the first argument, or
+   *     no arguments if the menu is dismissed
+   */
+  @ReactMethod
+  public void showPopupMenu(int reactTag, ReadableArray items, Callback error, Callback success) {
+    super.showPopupMenu(reactTag, items, error, success);
+  }
+
+  @ReactMethod
+  public void dismissPopupMenu() {
+    super.dismissPopupMenu();
+  }
+
+  /**
+   * LayoutAnimation API on Android is currently experimental. Therefore, it needs to be enabled
+   * explicitly in order to avoid regression in existing application written for iOS using this API.
+   *
+   * <p>Warning : This method will be removed in future version of React Native, and layout
+   * animation will be enabled by default, so always check for its existence before invoking it.
+   *
+   * <p>TODO(9139831) : remove this method once layout animation is fully stable.
+   *
+   * @param enabled whether layout animation is enabled or not
+   */
+  @ReactMethod
+  public void setLayoutAnimationEnabledExperimental(boolean enabled) {
+    super.setLayoutAnimationEnabledExperimental(enabled);
+  }
+
+  /**
+   * Configure an animation to be used for the native layout changes, and native views creation. The
+   * animation will only apply during the current batch operations.
+   *
+   * <p>TODO(7728153) : animating view deletion is currently not supported.
+   *
+   * @param config the configuration of the animation for view addition/removal/update.
+   * @param success will be called when the animation completes, or when the animation get
+   *     interrupted. In this case, callback parameter will be false.
+   * @param error will be called if there was an error processing the animation
+   */
+  @ReactMethod
+  public void configureNextLayoutAnimation(ReadableMap config, Callback success, Callback error) {
+    super.configureNextLayoutAnimation(config, success, error);
+  }
+
+  @ReactMethod
+  public void sendAccessibilityEvent(int tag, int eventType) {
+    super.sendAccessibilityEvent(tag, eventType);
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/Snapshot.java

@@ -0,0 +1,121 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import android.view.View;
+import android.view.ViewGroup;
+import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class Snapshot {
+  public static final String WIDTH = "width";
+  public static final String HEIGHT = "height";
+  public static final String ORIGIN_X = "originX";
+  public static final String ORIGIN_Y = "originY";
+  public static final String GLOBAL_ORIGIN_X = "globalOriginX";
+  public static final String GLOBAL_ORIGIN_Y = "globalOriginY";
+
+  public static final String CURRENT_WIDTH = "currentWidth";
+  public static final String CURRENT_HEIGHT = "currentHeight";
+  public static final String CURRENT_ORIGIN_X = "currentOriginX";
+  public static final String CURRENT_ORIGIN_Y = "currentOriginY";
+  public static final String CURRENT_GLOBAL_ORIGIN_X = "currentGlobalOriginX";
+  public static final String CURRENT_GLOBAL_ORIGIN_Y = "currentGlobalOriginY";
+
+  public static final String TARGET_WIDTH = "targetWidth";
+  public static final String TARGET_HEIGHT = "targetHeight";
+  public static final String TARGET_ORIGIN_X = "targetOriginX";
+  public static final String TARGET_ORIGIN_Y = "targetOriginY";
+  public static final String TARGET_GLOBAL_ORIGIN_X = "targetGlobalOriginX";
+  public static final String TARGET_GLOBAL_ORIGIN_Y = "targetGlobalOriginY";
+
+  public View view;
+  public ViewGroup parent;
+  public ViewManager viewManager;
+  public ViewManager parentViewManager;
+  public int width;
+  public int height;
+  public int originX;
+  public int originY;
+  public int globalOriginX;
+  public int globalOriginY;
+
+  public static ArrayList<String> targetKeysToTransform;
+  public static ArrayList<String> currentKeysToTransform;
+
+  Snapshot(View view, NativeViewHierarchyManager viewHierarchyManager) {
+    parent = (ViewGroup) view.getParent();
+    try {
+      viewManager = viewHierarchyManager.resolveViewManager(view.getId());
+      parentViewManager = viewHierarchyManager.resolveViewManager(parent.getId());
+    } catch (IllegalViewOperationException | NullPointerException e) {
+      // do nothing
+    }
+    width = view.getWidth();
+    height = view.getHeight();
+    originX = view.getLeft();
+    originY = view.getTop();
+    this.view = view;
+    int[] location = new int[2];
+    view.getLocationOnScreen(location);
+    globalOriginX = location[0];
+    globalOriginY = location[1];
+
+    targetKeysToTransform =
+        new ArrayList<>(
+            Arrays.asList(
+                Snapshot.TARGET_WIDTH,
+                Snapshot.TARGET_HEIGHT,
+                Snapshot.TARGET_ORIGIN_X,
+                Snapshot.TARGET_ORIGIN_Y,
+                Snapshot.TARGET_GLOBAL_ORIGIN_X,
+                Snapshot.TARGET_GLOBAL_ORIGIN_Y));
+    currentKeysToTransform =
+        new ArrayList<>(
+            Arrays.asList(
+                Snapshot.CURRENT_WIDTH,
+                Snapshot.CURRENT_HEIGHT,
+                Snapshot.CURRENT_ORIGIN_X,
+                Snapshot.CURRENT_ORIGIN_Y,
+                Snapshot.CURRENT_GLOBAL_ORIGIN_X,
+                Snapshot.CURRENT_GLOBAL_ORIGIN_Y));
+  }
+
+  private void addTargetConfig(HashMap<String, Object> data) {
+    data.put(Snapshot.TARGET_ORIGIN_Y, originY);
+    data.put(Snapshot.TARGET_ORIGIN_X, originX);
+    data.put(Snapshot.TARGET_GLOBAL_ORIGIN_Y, globalOriginY);
+    data.put(Snapshot.TARGET_GLOBAL_ORIGIN_X, globalOriginX);
+    data.put(Snapshot.TARGET_HEIGHT, height);
+    data.put(Snapshot.TARGET_WIDTH, width);
+  }
+
+  private void addCurrentConfig(HashMap<String, Object> data) {
+    data.put(Snapshot.CURRENT_ORIGIN_Y, originY);
+    data.put(Snapshot.CURRENT_ORIGIN_X, originX);
+    data.put(Snapshot.CURRENT_GLOBAL_ORIGIN_Y, globalOriginY);
+    data.put(Snapshot.CURRENT_GLOBAL_ORIGIN_X, globalOriginX);
+    data.put(Snapshot.CURRENT_HEIGHT, height);
+    data.put(Snapshot.CURRENT_WIDTH, width);
+  }
+
+  public HashMap<String, Object> toTargetMap() {
+    HashMap<String, Object> data = new HashMap<>();
+    addTargetConfig(data);
+    return data;
+  }
+
+  public HashMap<String, Object> toCurrentMap() {
+    HashMap<String, Object> data = new HashMap<>();
+    addCurrentConfig(data);
+    return data;
+  }
+
+  public HashMap<String, Object> toLayoutMap(Snapshot target) {
+    HashMap<String, Object> data = target.toTargetMap();
+    addCurrentConfig(data);
+    return data;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/ViewHierarchyObserver.java

@@ -0,0 +1,12 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import android.view.View;
+import android.view.ViewGroup;
+
+public interface ViewHierarchyObserver {
+  void onViewRemoval(View view, ViewGroup parent, Snapshot before, Runnable callback);
+
+  void onViewCreate(View view, ViewGroup parent, Snapshot after);
+
+  void onViewUpdate(View view, Snapshot before, Snapshot after);
+}

package/android/src/main/java/com/swmansion/reanimated/nodes/AlwaysNode.java

@@ -0,0 +1,29 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.MapUtils;
+import com.swmansion.reanimated.NodesManager;
+
+public class AlwaysNode extends Node implements FinalNode {
+  public AlwaysNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mNodeToBeEvaluated =
+        MapUtils.getInt(
+            config,
+            "what",
+            "Reanimated: Argument passed to always node is either of wrong type or is missing.");
+  }
+
+  private int mNodeToBeEvaluated;
+
+  @Override
+  public void update() {
+    this.value();
+  }
+
+  @Override
+  protected Double evaluate() {
+    mNodesManager.findNodeById(mNodeToBeEvaluated, Node.class).value();
+    return ZERO;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/nodes/BezierNode.java

@@ -0,0 +1,87 @@
+package com.swmansion.reanimated.nodes;
+
+import android.graphics.PointF;
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.MapUtils;
+import com.swmansion.reanimated.NodesManager;
+
+public class BezierNode extends Node {
+
+  private static class CubicBezierInterpolator {
+
+    protected PointF start;
+    protected PointF end;
+    protected PointF a = new PointF();
+    protected PointF b = new PointF();
+    protected PointF c = new PointF();
+
+    public CubicBezierInterpolator(PointF start, PointF end) {
+      this.start = start;
+      this.end = end;
+    }
+
+    public CubicBezierInterpolator(float startX, float startY, float endX, float endY) {
+      this(new PointF(startX, startY), new PointF(endX, endY));
+    }
+
+    public float getInterpolation(float time) {
+      return getBezierCoordinateY(getXForTime(time));
+    }
+
+    protected float getBezierCoordinateY(float time) {
+      c.y = 3 * start.y;
+      b.y = 3 * (end.y - start.y) - c.y;
+      a.y = 1 - c.y - b.y;
+      return time * (c.y + time * (b.y + time * a.y));
+    }
+
+    protected float getXForTime(float time) {
+      float x = time;
+      float z;
+      for (int i = 1; i < 14; i++) {
+        z = getBezierCoordinateX(x) - time;
+        if (Math.abs(z) < 1e-3) {
+          break;
+        }
+        x -= z / getXDerivate(x);
+      }
+      return x;
+    }
+
+    private float getXDerivate(float t) {
+      return c.x + t * (2 * b.x + 3 * a.x * t);
+    }
+
+    private float getBezierCoordinateX(float time) {
+      c.x = 3 * start.x;
+      b.x = 3 * (end.x - start.x) - c.x;
+      a.x = 1 - c.x - b.x;
+      return time * (c.x + time * (b.x + time * a.x));
+    }
+  }
+
+  private final int mInputID;
+  private final CubicBezierInterpolator mInterpolator;
+
+  public BezierNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+
+    mInputID =
+        MapUtils.getInt(
+            config,
+            "input",
+            "Reanimated: Argument passed to bezier node is either of wrong type or is missing.");
+
+    float startX = (float) config.getDouble("mX1");
+    float startY = (float) config.getDouble("mY1");
+    float endX = (float) config.getDouble("mX2");
+    float endY = (float) config.getDouble("mY2");
+    mInterpolator = new CubicBezierInterpolator(startX, startY, endX, endY);
+  }
+
+  @Override
+  protected Double evaluate() {
+    Double in = (Double) mNodesManager.getNodeValue(mInputID);
+    return Double.valueOf(mInterpolator.getInterpolation(in.floatValue()));
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/nodes/BlockNode.java

@@ -0,0 +1,24 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+
+public class BlockNode extends Node {
+
+  private final int[] mBlock;
+
+  public BlockNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mBlock = Utils.processIntArray(config.getArray("block"));
+  }
+
+  @Override
+  protected Object evaluate() {
+    Object res = null;
+    for (int i = 0; i < mBlock.length; i++) {
+      res = mNodesManager.findNodeById(mBlock[i], Node.class).value();
+    }
+    return res;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/nodes/CallFuncNode.java

@@ -0,0 +1,49 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+
+public class CallFuncNode extends Node {
+
+  private String mPreviousCallID;
+  private final int mWhatNodeID;
+  private final int[] mArgs;
+  private final int[] mParams;
+
+  public CallFuncNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mWhatNodeID = config.getInt("what");
+    mParams = Utils.processIntArray(config.getArray("params"));
+    mArgs = Utils.processIntArray(config.getArray("args"));
+  }
+
+  private void beginContext() {
+    mPreviousCallID = mNodesManager.updateContext.callID;
+    mNodesManager.updateContext.callID =
+        mNodesManager.updateContext.callID + '/' + String.valueOf(mNodeID);
+    for (int i = 0; i < mParams.length; i++) {
+      int paramId = mParams[i];
+      ParamNode paramNode = mNodesManager.findNodeById(paramId, ParamNode.class);
+      paramNode.beginContext(mArgs[i], mPreviousCallID);
+    }
+  }
+
+  private void endContext() {
+    for (int i = 0; i < mParams.length; i++) {
+      int paramId = mParams[i];
+      ParamNode paramNode = mNodesManager.findNodeById(paramId, ParamNode.class);
+      paramNode.endContext();
+    }
+    mNodesManager.updateContext.callID = mPreviousCallID;
+  }
+
+  @Override
+  protected Object evaluate() {
+    beginContext();
+    Node whatNode = mNodesManager.findNodeById(mWhatNodeID, Node.class);
+    Object retVal = whatNode.value();
+    endContext();
+    return retVal;
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/nodes/ClockNode.java

@@ -0,0 +1,38 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+
+public class ClockNode extends Node implements NodesManager.OnAnimationFrame {
+
+  public boolean isRunning;
+
+  public ClockNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+  }
+
+  public void start() {
+    if (isRunning) {
+      return;
+    }
+    isRunning = true;
+    mNodesManager.postOnAnimation(this);
+  }
+
+  public void stop() {
+    isRunning = false;
+  }
+
+  @Override
+  protected Double evaluate() {
+    return mNodesManager.currentFrameTimeMs;
+  }
+
+  @Override
+  public void onAnimationFrame(double timestampMs) {
+    if (isRunning) {
+      markUpdated();
+      mNodesManager.postOnAnimation(this);
+    }
+  }
+}