react-native-reanimated 2.6.0 → 3.0.0-rc.0

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

@@ -1,5 +1,9 @@
 #pragma once
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <JFabricUIManager.h>
+#endif
+
 #include <ReactCommon/CallInvokerHolder.h>
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
@@ -128,27 +132,48 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
       jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
           jsCallInvokerHolder,
       jni::alias_ref<AndroidScheduler::javaobject> scheduler,
-      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations);
+      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+      ,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager
+#endif
+      /**/);
   static void registerNatives();
 
+  ~NativeProxy();
+
  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;
-
+  std::shared_ptr<Scheduler> scheduler_;
+#ifdef RCT_NEW_ARCH_ENABLED
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+
+// removed temporary, new event listener mechanism need fix on the RN side
+// std::shared_ptr<facebook::react::Scheduler> reactScheduler_;
+// std::shared_ptr<EventListener> eventListener_;
+#endif
+#ifdef RCT_NEW_ARCH_ENABLED
+  void installJSIBindings(
+      jni::alias_ref<JFabricUIManager::javaobject> fabricUIManager);
+  void synchronouslyUpdateUIProps(
+      jsi::Runtime &rt,
+      Tag viewTag,
+      const jsi::Value &uiProps);
+#else
   void installJSIBindings();
+#endif
   bool isAnyHandlerWaitingForEvent(std::string);
+  void performOperations();
   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,
@@ -158,13 +183,26 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps);
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  void updateProps(jsi::Runtime &rt, int viewTag, const jsi::Object &props);
+  void scrollTo(int viewTag, double x, double y, bool animated);
+  std::vector<std::pair<std::string, double>> measure(int viewTag);
+#endif
 
   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);
+      jni::global_ref<LayoutAnimations::javaobject> _layoutAnimations
+#ifdef RCT_NEW_ARCH_ENABLED
+      ,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager
+#endif
+      /**/);
 };
 
 } // namespace reanimated

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

@@ -1,11 +1,8 @@
 package com.swmansion.reanimated;
 
-import android.util.SparseArray;
 import android.view.View;
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.GuardedRunnable;
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.JavaOnlyMap;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
@@ -28,30 +25,8 @@ import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
-import com.swmansion.reanimated.nodes.AlwaysNode;
-import com.swmansion.reanimated.nodes.BezierNode;
-import com.swmansion.reanimated.nodes.BlockNode;
-import com.swmansion.reanimated.nodes.CallFuncNode;
-import com.swmansion.reanimated.nodes.ClockNode;
-import com.swmansion.reanimated.nodes.ClockOpNode;
-import com.swmansion.reanimated.nodes.ConcatNode;
-import com.swmansion.reanimated.nodes.CondNode;
-import com.swmansion.reanimated.nodes.DebugNode;
-import com.swmansion.reanimated.nodes.EventNode;
-import com.swmansion.reanimated.nodes.FunctionNode;
-import com.swmansion.reanimated.nodes.JSCallNode;
-import com.swmansion.reanimated.nodes.Node;
-import com.swmansion.reanimated.nodes.NoopNode;
-import com.swmansion.reanimated.nodes.OperatorNode;
-import com.swmansion.reanimated.nodes.ParamNode;
-import com.swmansion.reanimated.nodes.PropsNode;
-import com.swmansion.reanimated.nodes.SetNode;
-import com.swmansion.reanimated.nodes.StyleNode;
-import com.swmansion.reanimated.nodes.TransformNode;
-import com.swmansion.reanimated.nodes.ValueNode;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -64,8 +39,6 @@ import javax.annotation.Nullable;
 
 public class NodesManager implements EventDispatcherListener {
 
-  private static final Double ZERO = Double.valueOf(0);
-
   public void scrollTo(int viewTag, double x, double y, boolean animated) {
     View view;
     try {
@@ -92,28 +65,23 @@ public class NodesManager implements EventDispatcherListener {
     void onAnimationFrame(double timestampMs);
   }
 
-  private AnimationsManager mAnimationManager = null;
-  private final SparseArray<Node> mAnimatedNodes = new SparseArray<>();
-  private final Map<String, EventNode> mEventMapping = new HashMap<>();
+  private AnimationsManager mAnimationManager;
   private final UIImplementation mUIImplementation;
   private final DeviceEventManagerModule.RCTDeviceEventEmitter mEventEmitter;
   private final ReactChoreographer mReactChoreographer;
   private final GuardedFrameCallback mChoreographerCallback;
   protected final UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
   private final AtomicBoolean mCallbackPosted = new AtomicBoolean();
-  private final NoopNode mNoopNode;
   private final ReactContext mContext;
   private final UIManagerModule mUIManager;
-
+  private ReactApplicationContext mReactApplicationContext;
   private RCTEventEmitter mCustomEventHandler;
   private List<OnAnimationFrame> mFrameCallbacks = new ArrayList<>();
   private ConcurrentLinkedQueue<CopiedEvent> mEventQueue = new ConcurrentLinkedQueue<>();
-  private boolean mWantRunUpdates;
-
   public double currentFrameTimeMs;
-  public final UpdateContext updateContext;
   public Set<String> uiProps = Collections.emptySet();
   public Set<String> nativeProps = Collections.emptySet();
+  private ReaCompatibility compatibility;
 
   public NativeProxy getNativeProxy() {
     return mNativeProxy;
@@ -137,8 +105,11 @@ public class NodesManager implements EventDispatcherListener {
   }
 
   public void initWithContext(ReactApplicationContext reactApplicationContext) {
+    mReactApplicationContext = reactApplicationContext;
     mNativeProxy = new NativeProxy(reactApplicationContext);
     mAnimationManager.setScheduler(getNativeProxy().getScheduler());
+    compatibility = new ReaCompatibility(reactApplicationContext);
+    compatibility.registerFabricEventListener(this);
   }
 
   private final class NativeUpdateOperation {
@@ -157,7 +128,6 @@ public class NodesManager implements EventDispatcherListener {
   public NodesManager(ReactContext context) {
     mContext = context;
     mUIManager = context.getNativeModule(UIManagerModule.class);
-    updateContext = new UpdateContext();
     mUIImplementation = mUIManager.getUIImplementation();
     mCustomEventNamesResolver = mUIManager.getDirectEventNamesResolver();
     mEventEmitter = context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
@@ -171,8 +141,6 @@ public class NodesManager implements EventDispatcherListener {
           }
         };
 
-    mNoopNode = new NoopNode(this);
-
     // We register as event listener at the end, because we pass `this` and we haven't finished
     // contructing an object yet.
     // This lead to a crash described in
@@ -214,7 +182,9 @@ public class NodesManager implements EventDispatcherListener {
   }
 
   private void performOperations() {
-    if (!mOperationsInBatch.isEmpty()) {
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      mNativeProxy.performOperations();
+    } else if (!mOperationsInBatch.isEmpty()) {
       final Queue<NativeUpdateOperation> copiedOperationsQueue = mOperationsInBatch;
       mOperationsInBatch = new LinkedList<>();
       final boolean trySynchronously = mTryRunBatchUpdatesSynchronously;
@@ -274,13 +244,9 @@ public class NodesManager implements EventDispatcherListener {
       }
     }
 
-    if (mWantRunUpdates) {
-      Node.runUpdates(updateContext);
-    }
     performOperations();
 
     mCallbackPosted.set(false);
-    mWantRunUpdates = false;
 
     if (!mFrameCallbacks.isEmpty() || !mEventQueue.isEmpty()) {
       // enqueue next frame
@@ -288,153 +254,6 @@ public class NodesManager implements EventDispatcherListener {
     }
   }
 
-  /**
-   * Null-safe way of getting node's value. If node is not present we return 0. This also matches
-   * iOS behavior when the app won't just crash.
-   */
-  public Object getNodeValue(int nodeID) {
-    Node node = mAnimatedNodes.get(nodeID);
-    if (node != null) {
-      return node.value();
-    }
-    return ZERO;
-  }
-
-  /**
-   * Null-safe way of getting node reference. This method always returns non-null instance. If the
-   * node is not present we try to return a "no-op" node that allows for "set" calls and always
-   * returns 0 as a value.
-   */
-  public <T extends Node> T findNodeById(int id, Class<T> type) {
-    Node node = mAnimatedNodes.get(id);
-    if (node == null) {
-      if (type == Node.class || type == ValueNode.class) {
-        return (T) mNoopNode;
-      }
-      throw new IllegalArgumentException(
-          "Requested node with id " + id + " of type " + type + " cannot be found");
-    }
-    if (type.isInstance(node)) {
-      return (T) node;
-    }
-    throw new IllegalArgumentException(
-        "Node with id "
-            + id
-            + " is of incompatible type "
-            + node.getClass()
-            + ", requested type was "
-            + type);
-  }
-
-  public void createNode(int nodeID, ReadableMap config) {
-    if (mAnimatedNodes.get(nodeID) != null) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node with ID " + nodeID + " already exists");
-    }
-    String type = config.getString("type");
-    final Node node;
-    if ("props".equals(type)) {
-      node = new PropsNode(nodeID, config, this, mUIImplementation);
-    } else if ("style".equals(type)) {
-      node = new StyleNode(nodeID, config, this);
-    } else if ("transform".equals(type)) {
-      node = new TransformNode(nodeID, config, this);
-    } else if ("value".equals(type)) {
-      node = new ValueNode(nodeID, config, this);
-    } else if ("block".equals(type)) {
-      node = new BlockNode(nodeID, config, this);
-    } else if ("cond".equals(type)) {
-      node = new CondNode(nodeID, config, this);
-    } else if ("op".equals(type)) {
-      node = new OperatorNode(nodeID, config, this);
-    } else if ("set".equals(type)) {
-      node = new SetNode(nodeID, config, this);
-    } else if ("debug".equals(type)) {
-      node = new DebugNode(nodeID, config, this);
-    } else if ("clock".equals(type)) {
-      node = new ClockNode(nodeID, config, this);
-    } else if ("clockStart".equals(type)) {
-      node = new ClockOpNode.ClockStartNode(nodeID, config, this);
-    } else if ("clockStop".equals(type)) {
-      node = new ClockOpNode.ClockStopNode(nodeID, config, this);
-    } else if ("clockTest".equals(type)) {
-      node = new ClockOpNode.ClockTestNode(nodeID, config, this);
-    } else if ("call".equals(type)) {
-      node = new JSCallNode(nodeID, config, this);
-    } else if ("bezier".equals(type)) {
-      node = new BezierNode(nodeID, config, this);
-    } else if ("event".equals(type)) {
-      node = new EventNode(nodeID, config, this);
-    } else if ("always".equals(type)) {
-      node = new AlwaysNode(nodeID, config, this);
-    } else if ("concat".equals(type)) {
-      node = new ConcatNode(nodeID, config, this);
-    } else if ("param".equals(type)) {
-      node = new ParamNode(nodeID, config, this);
-    } else if ("func".equals(type)) {
-      node = new FunctionNode(nodeID, config, this);
-    } else if ("callfunc".equals(type)) {
-      node = new CallFuncNode(nodeID, config, this);
-    } else {
-      throw new JSApplicationIllegalArgumentException("Unsupported node type: " + type);
-    }
-    mAnimatedNodes.put(nodeID, node);
-  }
-
-  public void dropNode(int tag) {
-    Node node = mAnimatedNodes.get(tag);
-    if (node != null) {
-      node.onDrop();
-    }
-    mAnimatedNodes.remove(tag);
-  }
-
-  public void connectNodes(int parentID, int childID) {
-    Node parentNode = mAnimatedNodes.get(parentID);
-    Node childNode = mAnimatedNodes.get(childID);
-    if (childNode == null) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node with ID " + childID + " does not exists");
-    }
-    parentNode.addChild(childNode);
-  }
-
-  public void disconnectNodes(int parentID, int childID) {
-    Node parentNode = mAnimatedNodes.get(parentID);
-    Node childNode = mAnimatedNodes.get(childID);
-    if (childNode == null) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node with ID " + childID + " does not exists");
-    }
-    parentNode.removeChild(childNode);
-  }
-
-  public void connectNodeToView(int nodeID, int viewTag) {
-    Node node = mAnimatedNodes.get(nodeID);
-    if (node == null) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node with ID " + nodeID + " does not exists");
-    }
-    if (!(node instanceof PropsNode)) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node connected to view should be" + "of type " + PropsNode.class.getName());
-    }
-    ((PropsNode) node).connectToView(viewTag);
-  }
-
-  public void disconnectNodeFromView(int nodeID, int viewTag) {
-    Node node = mAnimatedNodes.get(nodeID);
-    if (node == null) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node with ID " + nodeID + " does not exists");
-    }
-    if (!(node instanceof PropsNode)) {
-      throw new JSApplicationIllegalArgumentException(
-          "Animated node connected to view should be" + "of type " + PropsNode.class.getName());
-    }
-    ((PropsNode) node).disconnectFromView(viewTag);
-  }
-
   public void enqueueUpdateViewOnNativeThread(
       int viewTag, WritableMap nativeProps, boolean trySynchronously) {
     if (trySynchronously) {
@@ -443,41 +262,11 @@ public class NodesManager implements EventDispatcherListener {
     mOperationsInBatch.add(new NativeUpdateOperation(viewTag, nativeProps));
   }
 
-  public void attachEvent(int viewTag, String eventName, int eventNodeID) {
-    String key = viewTag + eventName;
-
-    EventNode node = (EventNode) mAnimatedNodes.get(eventNodeID);
-    if (node == null) {
-      throw new JSApplicationIllegalArgumentException(
-          "Event node " + eventNodeID + " does not exists");
-    }
-    if (mEventMapping.containsKey(key)) {
-      throw new JSApplicationIllegalArgumentException(
-          "Event handler already set for the given view and event type");
-    }
-
-    mEventMapping.put(key, node);
-  }
-
-  public void detachEvent(int viewTag, String eventName, int eventNodeID) {
-    String key = viewTag + eventName;
-    mEventMapping.remove(key);
-  }
-
   public void configureProps(Set<String> uiPropsSet, Set<String> nativePropsSet) {
     uiProps = uiPropsSet;
     nativeProps = nativePropsSet;
   }
 
-  public void getValue(int nodeID, Callback callback) {
-    callback.invoke(mAnimatedNodes.get(nodeID).value());
-  }
-
-  public void postRunUpdatesAfterAnimation() {
-    mWantRunUpdates = true;
-    startUpdatingOnAnimationFrame();
-  }
-
   public void postOnAnimation(OnAnimationFrame onAnimationFrame) {
     mFrameCallbacks.add(onAnimationFrame);
     startUpdatingOnAnimationFrame();
@@ -511,33 +300,15 @@ public class NodesManager implements EventDispatcherListener {
     // If the event has a different name in native, convert it to it's JS name.
     String eventName = mCustomEventNamesResolver.resolveCustomEventName(event.getEventName());
     int viewTag = event.getViewTag();
-    String key = viewTag + eventName;
-
     if (mCustomEventHandler != null) {
       event.dispatch(mCustomEventHandler);
     }
-
-    if (!mEventMapping.isEmpty()) {
-      EventNode node = mEventMapping.get(key);
-      if (node != null) {
-        event.dispatch(node);
-      }
-    }
   }
 
   private void handleEvent(int targetTag, String eventName, @Nullable WritableMap event) {
     if (mCustomEventHandler != null) {
       mCustomEventHandler.receiveEvent(targetTag, eventName, event);
     }
-
-    String key = targetTag + eventName;
-
-    if (!mEventMapping.isEmpty()) {
-      EventNode node = mEventMapping.get(key);
-      if (node != null) {
-        node.receiveEvent(targetTag, eventName, event);
-      }
-    }
   }
 
   public UIManagerModule.CustomEventNamesResolver getEventNameResolver() {
@@ -552,13 +323,6 @@ public class NodesManager implements EventDispatcherListener {
     mEventEmitter.emit(name, body);
   }
 
-  public void setValue(int nodeID, Double newValue) {
-    Node node = mAnimatedNodes.get(nodeID);
-    if (node != null) {
-      ((ValueNode) node).setValue(newValue);
-    }
-  }
-
   public void updateProps(int viewTag, Map<String, Object> props) {
     // TODO: update PropsNode to use this method instead of its own way of updating props
     boolean hasUIProps = false;
@@ -600,6 +364,10 @@ public class NodesManager implements EventDispatcherListener {
     }
   }
 
+  public void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+    compatibility.synchronouslyUpdateUIProps(viewTag, uiProps);
+  }
+
   public String obtainProp(int viewTag, String propName) {
     View view = mUIManager.resolveView(viewTag);
     String result =

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

@@ -1,18 +1,15 @@
 package com.swmansion.reanimated;
 
 import android.util.Log;
-import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.NativeViewHierarchyManager;
 import com.facebook.react.uimanager.UIBlock;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.UIManagerModuleListener;
-import com.swmansion.reanimated.transitions.TransitionModule;
 import java.util.ArrayList;
 import javax.annotation.Nullable;
 
@@ -27,11 +24,7 @@ public class ReanimatedModule extends ReactContextBaseJavaModule
   }
 
   private ArrayList<UIThreadOperation> mOperations = new ArrayList<>();
-
   private @Nullable NodesManager mNodesManager;
-  private @Nullable TransitionModule mTransitionManager;
-
-  private UIManagerModule mUIManager;
 
   public ReanimatedModule(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -43,9 +36,6 @@ public class ReanimatedModule extends ReactContextBaseJavaModule
     UIManagerModule uiManager = reactCtx.getNativeModule(UIManagerModule.class);
     reactCtx.addLifecycleEventListener(this);
     uiManager.addUIManagerListener(this);
-    mTransitionManager = new TransitionModule(uiManager);
-
-    mUIManager = uiManager;
   }
 
   @Override
@@ -115,121 +105,6 @@ public class ReanimatedModule extends ReactContextBaseJavaModule
     }
   }
 
-  @ReactMethod
-  public void animateNextTransition(int tag, ReadableMap config) {
-    mTransitionManager.animateNextTransition(tag, config);
-  }
-
-  @ReactMethod
-  public void createNode(final int tag, final ReadableMap config) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.createNode(tag, config);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void dropNode(final int tag) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.dropNode(tag);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void connectNodes(final int parentID, final int childID) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.connectNodes(parentID, childID);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void disconnectNodes(final int parentID, final int childID) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.disconnectNodes(parentID, childID);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void connectNodeToView(final int nodeID, final int viewTag) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.connectNodeToView(nodeID, viewTag);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void disconnectNodeFromView(final int nodeID, final int viewTag) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.disconnectNodeFromView(nodeID, viewTag);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void attachEvent(final int viewTag, final String eventName, final int eventNodeID) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.attachEvent(viewTag, eventName, eventNodeID);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void detachEvent(final int viewTag, final String eventName, final int eventNodeID) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.detachEvent(viewTag, eventName, eventNodeID);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void getValue(final int nodeID, final Callback callback) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.getValue(nodeID, callback);
-          }
-        });
-  }
-
-  @ReactMethod
-  public void setValue(final int nodeID, final Double newValue) {
-    mOperations.add(
-        new UIThreadOperation() {
-          @Override
-          public void execute(NodesManager nodesManager) {
-            nodesManager.setValue(nodeID, newValue);
-          }
-        });
-  }
-
   @ReactMethod
   public void addListener(String eventName) {
     // Keep: Required for RN built in Event Emitter Calls.

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

@@ -1,5 +1,6 @@
 package com.swmansion.reanimated.layoutReanimation;
 
+import android.app.Activity;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.View;
@@ -368,12 +369,18 @@ public class AnimationsManager implements ViewHierarchyObserver {
       preparedValues.put(key, PixelUtil.toDIPFromPixel((int) values.get(key)));
     }
 
-    DisplayMetrics displaymetrics = new DisplayMetrics();
-    mContext.getCurrentActivity().getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
-    int height = displaymetrics.heightPixels;
-    int width = displaymetrics.widthPixels;
-    preparedValues.put("windowWidth", PixelUtil.toDIPFromPixel(width));
-    preparedValues.put("windowHeight", PixelUtil.toDIPFromPixel(height));
+    DisplayMetrics displayMetrics = new DisplayMetrics();
+    Activity currentActivity = mContext.getCurrentActivity();
+    if (currentActivity != null) {
+      currentActivity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
+      int height = displayMetrics.heightPixels;
+      int width = displayMetrics.widthPixels;
+      preparedValues.put("windowWidth", PixelUtil.toDIPFromPixel(width));
+      preparedValues.put("windowHeight", PixelUtil.toDIPFromPixel(height));
+    } else {
+      preparedValues.put("windowWidth", PixelUtil.toDIPFromPixel(0));
+      preparedValues.put("windowHeight", PixelUtil.toDIPFromPixel(0));
+    }
     return preparedValues;
   }
 

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

@@ -3,13 +3,14 @@ package com.swmansion.reanimated.layoutReanimation;
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.soloader.SoLoader;
 import com.swmansion.reanimated.ReanimatedModule;
 import java.lang.ref.WeakReference;
 import java.util.Map;
 
 public class LayoutAnimations {
   static {
-    System.loadLibrary("reanimated");
+    SoLoader.loadLibrary("reanimated");
   }
 
   @DoNotStrip