react-native-reanimated 2.3.3 → 2.5.0

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

@@ -0,0 +1,251 @@
+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;
+
+@ReactModule(name = ReanimatedModule.NAME)
+public class ReanimatedModule extends ReactContextBaseJavaModule
+    implements LifecycleEventListener, UIManagerModuleListener {
+
+  public static final String NAME = "ReanimatedModule";
+
+  private interface UIThreadOperation {
+    void execute(NodesManager nodesManager);
+  }
+
+  private ArrayList<UIThreadOperation> mOperations = new ArrayList<>();
+
+  private @Nullable NodesManager mNodesManager;
+  private @Nullable TransitionModule mTransitionManager;
+
+  private UIManagerModule mUIManager;
+
+  public ReanimatedModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public void initialize() {
+    ReactApplicationContext reactCtx = getReactApplicationContext();
+    UIManagerModule uiManager = reactCtx.getNativeModule(UIManagerModule.class);
+    reactCtx.addLifecycleEventListener(this);
+    uiManager.addUIManagerListener(this);
+    mTransitionManager = new TransitionModule(uiManager);
+
+    mUIManager = uiManager;
+  }
+
+  @Override
+  public void onHostPause() {
+    if (mNodesManager != null) {
+      mNodesManager.onHostPause();
+    }
+  }
+
+  @Override
+  public void onHostResume() {
+    if (mNodesManager != null) {
+      mNodesManager.onHostResume();
+    }
+  }
+
+  @Override
+  public void onHostDestroy() {
+    // do nothing
+  }
+
+  @Override
+  public void willDispatchViewUpdates(final UIManagerModule uiManager) {
+    if (mOperations.isEmpty()) {
+      return;
+    }
+    final ArrayList<UIThreadOperation> operations = mOperations;
+    mOperations = new ArrayList<>();
+    uiManager.addUIBlock(
+        new UIBlock() {
+          @Override
+          public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+            NodesManager nodesManager = getNodesManager();
+            for (UIThreadOperation operation : operations) {
+              operation.execute(nodesManager);
+            }
+          }
+        });
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  /*package*/
+  public NodesManager getNodesManager() {
+    if (mNodesManager == null) {
+      mNodesManager = new NodesManager(getReactApplicationContext());
+    }
+
+    return mNodesManager;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public void installTurboModule() {
+    // When debugging in chrome the JS context is not available.
+    // https://github.com/facebook/react-native/blob/v0.67.0-rc.6/ReactAndroid/src/main/java/com/facebook/react/modules/blob/BlobCollector.java#L25
+    Utils.isChromeDebugger = getReactApplicationContext().getJavaScriptContextHolder().get() == 0;
+
+    if (!Utils.isChromeDebugger) {
+      this.getNodesManager().initWithContext(getReactApplicationContext());
+    } else {
+      Log.w(
+          "[REANIMATED]",
+          "Unable to create Reanimated Native Module. You can ignore this message if you are using Chrome Debugger now.");
+    }
+  }
+
+  @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.
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy();
+
+    if (mNodesManager != null) {
+      mNodesManager.onCatalystInstanceDestroy();
+    }
+  }
+}

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

@@ -0,0 +1,96 @@
+package com.swmansion.reanimated;
+
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_UI_MANAGER_MODULE_END;
+import static com.facebook.react.bridge.ReactMarkerConstants.CREATE_UI_MANAGER_MODULE_START;
+
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactPackage;
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMarker;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import com.facebook.react.uimanager.ReanimatedUIManager;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.systrace.Systrace;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ReanimatedPackage extends TurboReactPackage implements ReactPackage {
+
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(ReanimatedModule.NAME)) {
+      return new ReanimatedModule(reactContext);
+    }
+    if (name.equals(ReanimatedUIManager.NAME)) {
+      return createUIManager(reactContext);
+    }
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    Class<? extends NativeModule>[] moduleList =
+        new Class[] {
+          ReanimatedModule.class, ReanimatedUIManager.class,
+        };
+
+    final Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
+    for (Class<? extends NativeModule> moduleClass : moduleList) {
+      ReactModule reactModule = moduleClass.getAnnotation(ReactModule.class);
+
+      reactModuleInfoMap.put(
+          reactModule.name(),
+          new ReactModuleInfo(
+              reactModule.name(),
+              moduleClass.getName(),
+              true,
+              reactModule.needsEagerInit(),
+              reactModule.hasConstants(),
+              reactModule.isCxxModule(),
+              TurboModule.class.isAssignableFrom(moduleClass)));
+    }
+
+    return new ReactModuleInfoProvider() {
+      @Override
+      public Map<String, ReactModuleInfo> getReactModuleInfos() {
+        return reactModuleInfoMap;
+      }
+    };
+  }
+
+  private UIManagerModule createUIManager(final ReactApplicationContext reactContext) {
+    ReactMarker.logMarker(CREATE_UI_MANAGER_MODULE_START);
+    Systrace.beginSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "createUIManagerModule");
+    final ReactInstanceManager reactInstanceManager = getReactInstanceManager(reactContext);
+    int minTimeLeftInFrameForNonBatchedOperationMs = -1;
+    try {
+      return new ReanimatedUIManager(
+          reactContext,
+          reactInstanceManager.getOrCreateViewManagers(reactContext),
+          minTimeLeftInFrameForNonBatchedOperationMs);
+    } finally {
+      Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
+      ReactMarker.logMarker(CREATE_UI_MANAGER_MODULE_END);
+    }
+  }
+
+  /**
+   * Get the {@link ReactInstanceManager} used by this app. By default, assumes {@link
+   * ReactApplicationContext#getApplicationContext()} is an instance of {@link ReactApplication} and
+   * calls {@link ReactApplication#getReactNativeHost().getReactInstanceManager()}. Override this
+   * method if your application class does not implement {@code ReactApplication} or you simply have
+   * a different mechanism for storing a {@code ReactInstanceManager}, e.g. as a static field
+   * somewhere.
+   */
+  public ReactInstanceManager getReactInstanceManager(ReactApplicationContext reactContext) {
+    return ((ReactApplication) reactContext.getApplicationContext())
+        .getReactNativeHost()
+        .getReactInstanceManager();
+  }
+}

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

@@ -0,0 +1,51 @@
+package com.swmansion.reanimated;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.GuardedRunnable;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class Scheduler {
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private final HybridData mHybridData;
+
+  private final ReactApplicationContext mContext;
+  private final AtomicBoolean mActive = new AtomicBoolean(true);
+
+  private final Runnable mUIThreadRunnable =
+      new Runnable() {
+        @Override
+        public void run() {
+          if (mActive.get()) {
+            triggerUI();
+          }
+        }
+      };
+
+  public Scheduler(ReactApplicationContext context) {
+    mHybridData = initHybrid();
+    mContext = context;
+  }
+
+  private native HybridData initHybrid();
+
+  public native void triggerUI();
+
+  @DoNotStrip
+  private void scheduleOnUI() {
+    UiThreadUtil.runOnUiThread(
+        new GuardedRunnable(mContext.getExceptionHandler()) {
+          public void runGuarded() {
+            mUIThreadRunnable.run();
+          }
+        });
+  }
+
+  public void deactivate() {
+    mActive.set(false);
+  }
+}

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

@@ -0,0 +1,11 @@
+package com.swmansion.reanimated;
+
+import com.swmansion.reanimated.nodes.Node;
+import java.util.ArrayList;
+
+public class UpdateContext {
+
+  public long updateLoopID = 0;
+  public String callID = "";
+  public final ArrayList<Node> updatedNodes = new ArrayList<>();
+}

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

@@ -0,0 +1,32 @@
+package com.swmansion.reanimated;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Utils {
+
+  protected static boolean isChromeDebugger = false;
+
+  public static Map<String, Integer> processMapping(ReadableMap style) {
+    ReadableMapKeySetIterator iter = style.keySetIterator();
+    HashMap<String, Integer> mapping = new HashMap<>();
+    while (iter.hasNextKey()) {
+      String propKey = iter.nextKey();
+      int nodeIndex = style.getInt(propKey);
+      mapping.put(propKey, nodeIndex);
+    }
+    return mapping;
+  }
+
+  public static int[] processIntArray(ReadableArray ary) {
+    int size = ary.size();
+    int[] res = new int[size];
+    for (int i = 0; i < size; i++) {
+      res[i] = ary.getInt(i);
+    }
+    return res;
+  }
+}