react-native-reanimated 2.3.3 → 2.5.0

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

@@ -0,0 +1,377 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+
+public class OperatorNode extends Node {
+
+  private static boolean truthy(Object value) {
+    return value != null && !value.equals(0.);
+  }
+
+  private interface Operator {
+    double evaluate(Node[] input);
+  }
+
+  private abstract static class ReduceOperator implements Operator {
+    @Override
+    public double evaluate(Node[] input) {
+      double acc = input[0].doubleValue();
+      for (int i = 1; i < input.length; i++) {
+        acc = reduce(acc, input[i].doubleValue());
+      }
+      return acc;
+    }
+
+    public abstract double reduce(Double x, Double y);
+  }
+
+  private abstract static class SingleOperator implements Operator {
+    @Override
+    public double evaluate(Node[] input) {
+      return eval((Double) input[0].value());
+    }
+
+    public abstract double eval(Double x);
+  }
+
+  private abstract static class CompOperator implements Operator {
+    @Override
+    public double evaluate(Node[] input) {
+      return eval((Double) input[0].value(), (Double) input[1].value()) ? 1. : 0.;
+    }
+
+    public abstract boolean eval(Double x, Double y);
+  }
+
+  // arithmetic
+  private static final Operator ADD =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return x + y;
+        }
+      };
+  private static final Operator SUB =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return x - y;
+        }
+      };
+  private static final Operator MULTIPLY =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return x * y;
+        }
+      };
+  private static final Operator DIVIDE =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return x / y;
+        }
+      };
+  private static final Operator POW =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return Math.pow(x, y);
+        }
+      };
+  private static final Operator MODULO =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return ((x % y) + y) % y;
+        }
+      };
+  private static final Operator SQRT =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.sqrt(x);
+        }
+      };
+  private static final Operator LOG =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.log(x);
+        }
+      };
+  private static final Operator SIN =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.sin(x);
+        }
+      };
+  private static final Operator COS =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.cos(x);
+        }
+      };
+  private static final Operator TAN =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.tan(x);
+        }
+      };
+  private static final Operator ACOS =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.acos(x);
+        }
+      };
+  private static final Operator ASIN =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.asin(x);
+        }
+      };
+  private static final Operator ATAN =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.atan(x);
+        }
+      };
+  private static final Operator EXP =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.exp(x);
+        }
+      };
+  private static final Operator ROUND =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.round(x);
+        }
+      };
+  private static final Operator ABS =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.abs(x);
+        }
+      };
+  private static final Operator FLOOR =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.floor(x);
+        }
+      };
+  private static final Operator CEIL =
+      new SingleOperator() {
+        @Override
+        public double eval(Double x) {
+          return Math.ceil(x);
+        }
+      };
+  private static final Operator MIN =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return Math.min(x, y);
+        }
+      };
+  private static final Operator MAX =
+      new ReduceOperator() {
+        @Override
+        public double reduce(Double x, Double y) {
+          return Math.max(x, y);
+        }
+      };
+
+  // logical
+  private static final Operator AND =
+      new Operator() {
+        @Override
+        public double evaluate(Node[] input) {
+          boolean res = truthy(input[0].value());
+          for (int i = 1; i < input.length && res; i++) {
+            res = res && truthy(input[i].value());
+          }
+          return res ? 1. : 0.;
+        }
+      };
+  private static final Operator OR =
+      new Operator() {
+        @Override
+        public double evaluate(Node[] input) {
+          boolean res = truthy(input[0].value());
+          for (int i = 1; i < input.length && !res; i++) {
+            res = res || truthy(input[i].value());
+          }
+          return res ? 1. : 0.;
+        }
+      };
+  private static final Operator NOT =
+      new Operator() {
+        @Override
+        public double evaluate(Node[] input) {
+          return truthy(input[0].value()) ? 0. : 1.;
+        }
+      };
+  private static final Operator DEFINED =
+      new Operator() {
+        @Override
+        public double evaluate(Node[] input) {
+          Object res = input[0].value();
+          return (res != null && !(res instanceof Double && ((Double) res).isNaN())) ? 1. : 0.;
+        }
+      };
+
+  // comparison
+  private static final Operator LESS_THAN =
+      new CompOperator() {
+        @Override
+        public boolean eval(Double x, Double y) {
+          if (x == null || y == null) {
+            return false;
+          }
+          return x < y;
+        }
+      };
+  private static final Operator EQ =
+      new CompOperator() {
+        @Override
+        public boolean eval(Double x, Double y) {
+          if (x == null || y == null) {
+            return x == y;
+          }
+          return x.doubleValue() == y.doubleValue();
+        }
+      };
+  private static final Operator GREATER_THAN =
+      new CompOperator() {
+        @Override
+        public boolean eval(Double x, Double y) {
+          if (x == null || y == null) {
+            return false;
+          }
+          return x > y;
+        }
+      };
+  private static final Operator LESS_OR_EQ =
+      new CompOperator() {
+        @Override
+        public boolean eval(Double x, Double y) {
+          return x <= y;
+        }
+      };
+  private static final Operator GREATER_OR_EQ =
+      new CompOperator() {
+        @Override
+        public boolean eval(Double x, Double y) {
+          return x >= y;
+        }
+      };
+  private static final Operator NEQ =
+      new CompOperator() {
+        @Override
+        public boolean eval(Double x, Double y) {
+          if (x == null || y == null) {
+            return x == y;
+          }
+          return x.doubleValue() != y.doubleValue();
+        }
+      };
+
+  private final int[] mInputIDs;
+  private final Node[] mInputNodes;
+  private final Operator mOperator;
+
+  public OperatorNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mInputIDs = Utils.processIntArray(config.getArray("input"));
+    mInputNodes = new Node[mInputIDs.length];
+
+    String op = config.getString("op");
+    if ("add".equals(op)) {
+      mOperator = ADD;
+    } else if ("sub".equals(op)) {
+      mOperator = SUB;
+    } else if ("multiply".equals(op)) {
+      mOperator = MULTIPLY;
+    } else if ("divide".equals(op)) {
+      mOperator = DIVIDE;
+    } else if ("pow".equals(op)) {
+      mOperator = POW;
+    } else if ("modulo".equals(op)) {
+      mOperator = MODULO;
+    } else if ("sqrt".equals(op)) {
+      mOperator = SQRT;
+    } else if ("log".equals(op)) {
+      mOperator = LOG;
+    } else if ("sin".equals(op)) {
+      mOperator = SIN;
+    } else if ("cos".equals(op)) {
+      mOperator = COS;
+    } else if ("tan".equals(op)) {
+      mOperator = TAN;
+    } else if ("acos".equals(op)) {
+      mOperator = ACOS;
+    } else if ("asin".equals(op)) {
+      mOperator = ASIN;
+    } else if ("atan".equals(op)) {
+      mOperator = ATAN;
+    } else if ("exp".equals(op)) {
+      mOperator = EXP;
+    } else if ("round".equals(op)) {
+      mOperator = ROUND;
+    } else if ("and".equals(op)) {
+      mOperator = AND;
+    } else if ("or".equals(op)) {
+      mOperator = OR;
+    } else if ("not".equals(op)) {
+      mOperator = NOT;
+    } else if ("defined".equals(op)) {
+      mOperator = DEFINED;
+    } else if ("lessThan".equals(op)) {
+      mOperator = LESS_THAN;
+    } else if ("eq".equals(op)) {
+      mOperator = EQ;
+    } else if ("greaterThan".equals(op)) {
+      mOperator = GREATER_THAN;
+    } else if ("lessOrEq".equals(op)) {
+      mOperator = LESS_OR_EQ;
+    } else if ("greaterOrEq".equals(op)) {
+      mOperator = GREATER_OR_EQ;
+    } else if ("neq".equals(op)) {
+      mOperator = NEQ;
+    } else if ("abs".equals(op)) {
+      mOperator = ABS;
+    } else if ("floor".equals(op)) {
+      mOperator = FLOOR;
+    } else if ("ceil".equals(op)) {
+      mOperator = CEIL;
+    } else if ("max".equals(op)) {
+      mOperator = MAX;
+    } else if ("min".equals(op)) {
+      mOperator = MIN;
+    } else {
+      throw new JSApplicationIllegalArgumentException("Unrecognized operator " + op);
+    }
+  }
+
+  @Override
+  protected Object evaluate() {
+    for (int i = 0; i < mInputIDs.length; i++) {
+      mInputNodes[i] = mNodesManager.findNodeById(mInputIDs[i], Node.class);
+    }
+    return mOperator.evaluate(mInputNodes);
+  }
+}

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

@@ -0,0 +1,71 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.NodesManager;
+import java.util.Stack;
+
+public class ParamNode extends ValueNode {
+
+  private final Stack<Integer> mArgsStack;
+  private String mPrevCallID;
+
+  public ParamNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mArgsStack = new Stack<>();
+  }
+
+  @Override
+  public void setValue(Object value) {
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    String callID = mUpdateContext.callID;
+    mUpdateContext.callID = mPrevCallID;
+    ((ValueNode) node).setValue(value);
+    mUpdateContext.callID = callID;
+    forceUpdateMemoizedValue(value);
+  }
+
+  public void beginContext(Integer ref, String prevCallID) {
+    mPrevCallID = prevCallID;
+    mArgsStack.push(ref);
+  }
+
+  public void endContext() {
+    mArgsStack.pop();
+  }
+
+  @Override
+  protected Object evaluate() {
+    String callID = mUpdateContext.callID;
+    mUpdateContext.callID = mPrevCallID;
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    Object val = node.value();
+    mUpdateContext.callID = callID;
+    return val;
+  }
+
+  public void start() {
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    if (node instanceof ParamNode) {
+      ((ParamNode) node).start();
+    } else {
+      ((ClockNode) node).start();
+    }
+  }
+
+  public void stop() {
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    if (node instanceof ParamNode) {
+      ((ParamNode) node).stop();
+    } else {
+      ((ClockNode) node).stop();
+    }
+  }
+
+  public boolean isRunning() {
+    Node node = mNodesManager.findNodeById(mArgsStack.peek(), Node.class);
+    if (node instanceof ParamNode) {
+      return ((ParamNode) node).isRunning();
+    }
+    return ((ClockNode) node).isRunning;
+  }
+}

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

@@ -0,0 +1,153 @@
+package com.swmansion.reanimated.nodes;
+
+import android.view.View;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.ReactStylesDiffMap;
+import com.facebook.react.uimanager.UIImplementation;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.Utils;
+import java.util.Map;
+
+public class PropsNode extends Node implements FinalNode {
+
+  private final Map<String, Integer> mMapping;
+  private final UIImplementation mUIImplementation;
+  private int mConnectedViewTag = View.NO_ID;
+
+  private final JavaOnlyMap mPropMap;
+  private final ReactStylesDiffMap mDiffMap;
+
+  private static void addProp(WritableMap propMap, String key, Object value) {
+    if (value == null) {
+      propMap.putNull(key);
+    } else if (value instanceof Double) {
+      propMap.putDouble(key, (Double) value);
+    } else if (value instanceof Integer) {
+      propMap.putInt(key, (Integer) value);
+    } else if (value instanceof Number) {
+      propMap.putDouble(key, ((Number) value).doubleValue());
+    } else if (value instanceof Boolean) {
+      propMap.putBoolean(key, (Boolean) value);
+    } else if (value instanceof String) {
+      propMap.putString(key, (String) value);
+    } else if (value instanceof WritableArray) {
+      propMap.putArray(key, (WritableArray) value);
+    } else if (value instanceof WritableMap) {
+      propMap.putMap(key, (WritableMap) value);
+    } else {
+      throw new IllegalStateException("Unknown type of animated value");
+    }
+  }
+
+  public PropsNode(
+      int nodeID,
+      ReadableMap config,
+      NodesManager nodesManager,
+      UIImplementation uiImplementation) {
+    super(nodeID, config, nodesManager);
+    mMapping = Utils.processMapping(config.getMap("props"));
+    mUIImplementation = uiImplementation;
+    mPropMap = new JavaOnlyMap();
+    mDiffMap = new ReactStylesDiffMap(mPropMap);
+  }
+
+  public void connectToView(int viewTag) {
+    mConnectedViewTag = viewTag;
+    dangerouslyRescheduleEvaluate();
+  }
+
+  public void disconnectFromView(int viewTag) {
+    mConnectedViewTag = View.NO_ID;
+  }
+
+  @Override
+  protected Double evaluate() {
+    boolean hasUIProps = false;
+    boolean hasNativeProps = false;
+    boolean hasJSProps = false;
+    WritableMap jsProps = Arguments.createMap();
+    final WritableMap nativeProps = Arguments.createMap();
+
+    for (Map.Entry<String, Integer> entry : mMapping.entrySet()) {
+      Node node = mNodesManager.findNodeById(entry.getValue(), Node.class);
+      if (node instanceof StyleNode) {
+        WritableMap style = (WritableMap) node.value();
+        ReadableMapKeySetIterator iter = style.keySetIterator();
+        while (iter.hasNextKey()) {
+          String key = iter.nextKey();
+          WritableMap dest;
+          if (mNodesManager.uiProps.contains(key)) {
+            hasUIProps = true;
+            dest = mPropMap;
+          } else if (mNodesManager.nativeProps.contains(key)) {
+            hasNativeProps = true;
+            dest = nativeProps;
+          } else {
+            hasJSProps = true;
+            dest = jsProps;
+          }
+          ReadableType type = style.getType(key);
+          switch (type) {
+            case Number:
+              dest.putDouble(key, style.getDouble(key));
+              break;
+            case String:
+              dest.putString(key, style.getString(key));
+              break;
+            case Array:
+              dest.putArray(key, (WritableArray) style.getArray(key));
+              break;
+            default:
+              throw new IllegalArgumentException("Unexpected type " + type);
+          }
+        }
+      } else {
+        String key = entry.getKey();
+        Object value = node.value();
+        if (mNodesManager.uiProps.contains(key)) {
+          hasUIProps = true;
+          addProp(mPropMap, key, value);
+        } else {
+          hasNativeProps = true;
+          addProp(nativeProps, key, value);
+        }
+      }
+    }
+
+    if (mConnectedViewTag != View.NO_ID) {
+      if (hasUIProps) {
+        mUIImplementation.synchronouslyUpdateViewOnUIThread(mConnectedViewTag, mDiffMap);
+      }
+      if (hasNativeProps) {
+        mNodesManager.enqueueUpdateViewOnNativeThread(mConnectedViewTag, nativeProps, false);
+      }
+      if (hasJSProps) {
+        WritableMap evt = Arguments.createMap();
+        evt.putInt("viewTag", mConnectedViewTag);
+        evt.putMap("props", jsProps);
+        mNodesManager.sendEvent("onReanimatedPropsChange", evt);
+      }
+    }
+
+    return ZERO;
+  }
+
+  @Override
+  public void update() {
+    // Since we are updating nodes after detaching them from views there is a time where it's
+    // possible that the view was disconnected and still receive an update, this is normal and
+    // we can simply skip that update.
+    if (mConnectedViewTag == View.NO_ID) {
+      return;
+    }
+
+    // call value for side effect (diff map update via changes made to prop map)
+    value();
+  }
+}

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

@@ -0,0 +1,32 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.swmansion.reanimated.MapUtils;
+import com.swmansion.reanimated.NodesManager;
+
+public class SetNode extends Node {
+
+  private int mWhatNodeID, mValueNodeID;
+
+  public SetNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mWhatNodeID =
+        MapUtils.getInt(
+            config,
+            "what",
+            "Reanimated: First argument passed to set node is either of wrong type or is missing.");
+    mValueNodeID =
+        MapUtils.getInt(
+            config,
+            "value",
+            "Reanimated: Second argument passed to set node is either of wrong type or is missing.");
+  }
+
+  @Override
+  protected Object evaluate() {
+    Object newValue = mNodesManager.getNodeValue(mValueNodeID);
+    ValueNode what = mNodesManager.findNodeById(mWhatNodeID, ValueNode.class);
+    what.setValue(newValue);
+    return newValue;
+  }
+}

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

@@ -0,0 +1,40 @@
+package com.swmansion.reanimated.nodes;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+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;
+import java.util.Map;
+
+public class StyleNode extends Node {
+
+  private final Map<String, Integer> mMapping;
+
+  public StyleNode(int nodeID, ReadableMap config, NodesManager nodesManager) {
+    super(nodeID, config, nodesManager);
+    mMapping = Utils.processMapping(config.getMap("style"));
+  }
+
+  @Override
+  protected WritableMap evaluate() {
+    JavaOnlyMap propMap = new JavaOnlyMap();
+    for (Map.Entry<String, Integer> entry : mMapping.entrySet()) {
+      Node node = mNodesManager.findNodeById(entry.getValue(), Node.class);
+      if (node instanceof TransformNode) {
+        propMap.putArray(entry.getKey(), (WritableArray) node.value());
+      } else {
+        Object val = node.value();
+        if (val instanceof Double) {
+          propMap.putDouble(entry.getKey(), (Double) val);
+        } else if (val instanceof String) {
+          propMap.putString(entry.getKey(), (String) val);
+        } else {
+          throw new IllegalStateException("Wrong style form");
+        }
+      }
+    }
+    return propMap;
+  }
+}