react-native-reanimated 2.3.3 → 2.5.0

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

@@ -0,0 +1,73 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.MapUtils;
+import com.swmansion.reanimated.NodesManager;
+
+public abstract class ClockOpNode extends Node {
+
+  public static class ClockStartNode extends ClockOpNode {
+    public ClockStartNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+      super(nodeID, config, nodesManager);
+    }
+
+    @Override
+    protected Double eval(Node clock) {
+      if (clock instanceof ParamNode) {
+        ((ParamNode) clock).start();
+      } else {
+        ((ClockNode) clock).start();
+      }
+      return ZERO;
+    }
+  }
+
+  public static class ClockStopNode extends ClockOpNode {
+    public ClockStopNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+      super(nodeID, config, nodesManager);
+    }
+
+    @Override
+    protected Double eval(Node clock) {
+      if (clock instanceof ParamNode) {
+        ((ParamNode) clock).stop();
+      } else {
+        ((ClockNode) clock).stop();
+      }
+      return ZERO;
+    }
+  }
+
+  public static class ClockTestNode extends ClockOpNode {
+    public ClockTestNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+      super(nodeID, config, nodesManager);
+    }
+
+    @Override
+    protected Double eval(Node clock) {
+      if (clock instanceof ParamNode) {
+        return ((ParamNode) clock).isRunning() ? 1. : 0.;
+      }
+      return ((ClockNode) clock).isRunning ? 1. : 0.;
+    }
+  }
+
+  private int clockID;
+
+  public ClockOpNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    clockID =
+        MapUtils.getInt(
+            config,
+            "clock",
+            "Reanimated: Argument passed to clock node is either of wrong type or is missing.");
+  }
+
+  @Override
+  protected Double evaluate() {
+    Node clock = mNodesManager.findNodeById(clockID, Node.class);
+    return eval(clock);
+  }
+
+  protected abstract Double eval(Node clock);
+}

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

@@ -0,0 +1,36 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+import java.text.NumberFormat;
+import java.util.Locale;
+
+public class ConcatNode extends Node {
+  private final int[] mInputIDs;
+  private static final NumberFormat sFormatter = NumberFormat.getInstance(Locale.ENGLISH);
+
+  static {
+    sFormatter.setMinimumFractionDigits(0);
+    sFormatter.setGroupingUsed(false);
+  }
+
+  public ConcatNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mInputIDs = Utils.processIntArray(config.getArray("input"));
+  }
+
+  @Override
+  protected String evaluate() {
+    StringBuilder builder = new StringBuilder();
+    for (int i = 0; i < mInputIDs.length; i++) {
+      Node inputNodes = mNodesManager.findNodeById(mInputIDs[i], Node.class);
+      Object value = inputNodes.value();
+      if (value instanceof Double) {
+        value = sFormatter.format((Double) value);
+      }
+      builder.append(value);
+    }
+    return builder.toString();
+  }
+}

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

@@ -0,0 +1,41 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.MapUtils;
+import com.swmansion.reanimated.NodesManager;
+
+public class CondNode extends Node {
+
+  private final int mCondID, mIfBlockID, mElseBlockID;
+
+  public CondNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mCondID =
+        MapUtils.getInt(
+            config,
+            "cond",
+            "Reanimated: First argument passed to cond node is either of wrong type or is missing.");
+    mIfBlockID =
+        MapUtils.getInt(
+            config,
+            "ifBlock",
+            "Reanimated: Second argument passed to cond node is either of wrong type or is missing.");
+    mElseBlockID =
+        config.hasKey("elseBlock")
+            ? MapUtils.getInt(
+                config,
+                "elseBlock",
+                "Reanimated: Second argument passed to cond node is either of wrong type or is missing.")
+            : -1;
+  }
+
+  @Override
+  protected Object evaluate() {
+    Object cond = mNodesManager.getNodeValue(mCondID);
+    if (cond instanceof Number && ((Number) cond).doubleValue() != 0.0) {
+      // This is not a good way to compare doubles but in this case it is what we want
+      return mIfBlockID != -1 ? mNodesManager.getNodeValue(mIfBlockID) : ZERO;
+    }
+    return mElseBlockID != -1 ? mNodesManager.getNodeValue(mElseBlockID) : ZERO;
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.swmansion.reanimated.nodes;
+
+import android.util.Log;
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.MapUtils;
+import com.swmansion.reanimated.NodesManager;
+
+public class DebugNode extends Node {
+
+  private final String mMessage;
+  private final int mValueID;
+
+  public DebugNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mMessage =
+        MapUtils.getString(
+            config,
+            "message",
+            "Reanimated: First argument passed to debug node is either of wrong type or is missing.");
+    mValueID =
+        MapUtils.getInt(
+            config,
+            "value",
+            "Reanimated: Second argument passed to debug node is either of wrong type or is missing.");
+  }
+
+  @Override
+  protected Object evaluate() {
+    Object value = mNodesManager.findNodeById(mValueID, Node.class).value();
+    Log.d("REANIMATED", String.format("%s %s", mMessage, value));
+    return value;
+  }
+}

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

@@ -0,0 +1,83 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.swmansion.reanimated.NodesManager;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nullable;
+
+public class EventNode extends Node implements RCTEventEmitter {
+
+  private static class EventMap {
+    private final int nodeID;
+    private final String[] path;
+
+    public EventMap(ReadableArray eventPath) {
+      int size = eventPath.size();
+      path = new String[size - 1];
+      for (int i = 0; i < size - 1; i++) {
+        path[i] = eventPath.getString(i);
+      }
+      nodeID = eventPath.getInt(size - 1);
+    }
+
+    public Double lookupValue(ReadableMap event) {
+      ReadableMap map = event;
+      for (int i = 0; map != null && i < path.length - 1; i++) {
+        String key = path[i];
+        map = map.hasKey(key) ? map.getMap(key) : null;
+      }
+      if (map != null) {
+        String key = path[path.length - 1];
+        return map.hasKey(key) ? map.getDouble(key) : null;
+      }
+      return null;
+    }
+  }
+
+  private static List<EventMap> processMapping(ReadableArray mapping) {
+    int size = mapping.size();
+    List<EventMap> res = new ArrayList<>(size);
+    for (int i = 0; i < size; i++) {
+      res.add(new EventMap(mapping.getArray(i)));
+    }
+    return res;
+  }
+
+  private final List<EventMap> mMapping;
+
+  public EventNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mMapping = processMapping(config.getArray("argMapping"));
+  }
+
+  @Override
+  public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+    if (event == null) {
+      throw new IllegalArgumentException("Animated events must have event data.");
+    }
+
+    for (int i = 0; i < mMapping.size(); i++) {
+      EventMap eventMap = mMapping.get(i);
+      Double value = eventMap.lookupValue(event);
+      if (value != null) {
+        mNodesManager.findNodeById(eventMap.nodeID, ValueNode.class).setValue(value);
+      }
+    }
+  }
+
+  @Override
+  public void receiveTouches(
+      String eventName, WritableArray touches, WritableArray changedIndices) {
+    throw new RuntimeException("receiveTouches is not support by animated events");
+  }
+
+  @Override
+  protected Double evaluate() {
+    return ZERO;
+  }
+}

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

@@ -0,0 +1,5 @@
+package com.swmansion.reanimated.nodes;
+
+public interface FinalNode {
+  void update();
+}

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

@@ -0,0 +1,20 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+
+public class FunctionNode extends Node {
+
+  private final int mWhatNodeID;
+
+  public FunctionNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mWhatNodeID = config.getInt("what");
+  }
+
+  @Override
+  protected Object evaluate() {
+    Node what = mNodesManager.findNodeById(mWhatNodeID, Node.class);
+    return what.value();
+  }
+}

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

@@ -0,0 +1,41 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+
+public class JSCallNode extends Node {
+
+  private final int[] mInputIDs;
+
+  public JSCallNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mInputIDs = Utils.processIntArray(config.getArray("input"));
+  }
+
+  @Override
+  protected Double evaluate() {
+    WritableArray args = Arguments.createArray();
+    for (int i = 0; i < mInputIDs.length; i++) {
+      Node node = mNodesManager.findNodeById(mInputIDs[i], Node.class);
+      if (node.value() == null) {
+        args.pushNull();
+      } else {
+        Object value = node.value();
+        if (value instanceof String) {
+          args.pushString((String) value);
+        } else {
+          args.pushDouble(node.doubleValue());
+        }
+      }
+    }
+    WritableMap eventData = Arguments.createMap();
+    eventData.putInt("id", mNodeID);
+    eventData.putArray("args", args);
+    mNodesManager.sendEvent("onReanimatedCall", eventData);
+    return ZERO;
+  }
+}

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

@@ -0,0 +1,139 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.UpdateContext;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+import javax.annotation.Nullable;
+
+public abstract class Node {
+
+  public static final Double ZERO = Double.valueOf(0);
+  public static final Double ONE = Double.valueOf(1);
+
+  protected final int mNodeID;
+  protected final NodesManager mNodesManager;
+
+  protected final UpdateContext mUpdateContext;
+
+  private final Map<String, Long> mLastLoopID = new HashMap<>();
+  private final Map<String, Object> mMemoizedValue = new HashMap<>();
+  private @Nullable List<Node> mChildren; /* lazy-initialized when a child is added */
+
+  public Node(int nodeID, @Nullable ReadableMap config, NodesManager nodesManager) {
+    mLastLoopID.put("", -1L);
+    mNodeID = nodeID;
+    mNodesManager = nodesManager;
+    mUpdateContext = nodesManager.updateContext;
+  }
+
+  protected abstract @Nullable Object evaluate();
+
+  public final @Nullable Object value() {
+    if (!mLastLoopID.containsKey(mUpdateContext.callID)
+        || mLastLoopID.get(mUpdateContext.callID) < mUpdateContext.updateLoopID) {
+      mLastLoopID.put(mUpdateContext.callID, mUpdateContext.updateLoopID);
+      Object result = evaluate();
+      mMemoizedValue.put(mUpdateContext.callID, result);
+
+      return result;
+    }
+    return mMemoizedValue.get(mUpdateContext.callID);
+  }
+
+  /**
+   * This method will never return null. If value is null or of a different type we try to cast and
+   * return 0 if we fail to properly cast the value. This is to match iOS behavior where the node
+   * would not throw even if the value was not set.
+   */
+  public final Double doubleValue() {
+    Object value = value();
+    if (value == null) {
+      return ZERO;
+    } else if (value instanceof Double) {
+      return (Double) value;
+    } else if (value instanceof Number) {
+      return Double.valueOf(((Number) value).doubleValue());
+    } else if (value instanceof Boolean) {
+      return ((Boolean) value).booleanValue() ? ONE : ZERO;
+    }
+    throw new IllegalStateException("Value of node " + this + " cannot be cast to a number");
+  }
+
+  public void addChild(Node child) {
+    if (mChildren == null) {
+      mChildren = new ArrayList<>();
+    }
+    mChildren.add(child);
+    child.dangerouslyRescheduleEvaluate();
+  }
+
+  public void removeChild(Node child) {
+    if (mChildren != null) {
+      mChildren.remove(child);
+    }
+  }
+
+  protected void markUpdated() {
+    UiThreadUtil.assertOnUiThread();
+    mUpdateContext.updatedNodes.add(this);
+    mNodesManager.postRunUpdatesAfterAnimation();
+  }
+
+  public void onDrop() {
+    // noop
+  }
+
+  protected final void dangerouslyRescheduleEvaluate() {
+    mLastLoopID.put(mUpdateContext.callID, -1L);
+    markUpdated();
+  }
+
+  protected final void forceUpdateMemoizedValue(Object value) {
+    mMemoizedValue.put(mUpdateContext.callID, value);
+    markUpdated();
+  }
+
+  private static void findAndUpdateNodes(
+      Node node, Set<Node> visitedNodes, Stack<FinalNode> finalNodes) {
+    if (visitedNodes.contains(node)) {
+      return;
+    } else {
+      visitedNodes.add(node);
+    }
+
+    List<Node> children = node.mChildren;
+    if (children != null) {
+      for (Node child : children) {
+        findAndUpdateNodes(child, visitedNodes, finalNodes);
+      }
+    }
+    if (node instanceof FinalNode) {
+      finalNodes.push((FinalNode) node);
+    }
+  }
+
+  public static void runUpdates(UpdateContext updateContext) {
+    UiThreadUtil.assertOnUiThread();
+    ArrayList<Node> updatedNodes = updateContext.updatedNodes;
+    Set<Node> visitedNodes = new HashSet<>();
+    Stack<FinalNode> finalNodes = new Stack<>();
+    for (int i = 0; i < updatedNodes.size(); i++) {
+      findAndUpdateNodes(updatedNodes.get(i), visitedNodes, finalNodes);
+      if (i == updatedNodes.size() - 1) {
+        while (!finalNodes.isEmpty()) {
+          finalNodes.pop().update();
+        }
+      }
+    }
+    updatedNodes.clear();
+    updateContext.updateLoopID++;
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.swmansion.reanimated.nodes;
+
+import com.swmansion.reanimated.NodesManager;
+
+/**
+ * This node is used by {@link NodesManager} to return in place of a missing node that might have
+ * been requested. This way we avoid a top of null-checks and we make nodes manager compatible with
+ * the iOS code which does not crash for missing nodes. In most of the cases it is desirable to
+ * handle missing nodes gracefully as it usually means the node hasn't been hooked under animated
+ * view prop but is referenced in the graph (e.g. to support some edge case).
+ */
+public class NoopNode extends ValueNode {
+
+  public NoopNode(NodesManager nodesManager) {
+    super(-2, null, nodesManager);
+  }
+
+  @Override
+  public void setValue(Object value) {
+    // no-op
+  }
+
+  @Override
+  public void addChild(Node child) {
+    // no-op
+  }
+
+  @Override
+  public void removeChild(Node child) {
+    // no-op
+  }
+
+  @Override
+  protected void markUpdated() {
+    // no-op
+  }
+}