react-native-reanimated 3.0.0-rc.9 → 3.0.1

package/android/proguard-rules.pro

@@ -0,0 +1,2 @@
+-keep class com.swmansion.reanimated.** { *; }
+-keep class com.facebook.react.turbomodule.** { *; }

package/android/src/fabric/java/com/swmansion/reanimated/NativeProxy.java

@@ -1,328 +1,96 @@
 package com.swmansion.reanimated;
 
-import android.os.SystemClock;
 import android.util.Log;
-import androidx.annotation.Nullable;
+
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
-import com.facebook.react.ReactApplication;
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableNativeArray;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.bridge.queue.MessageQueueThread;
 import com.facebook.react.fabric.FabricUIManager;
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
 import com.facebook.react.uimanager.UIManagerHelper;
-import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.common.UIManagerType;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
-import com.facebook.soloader.SoLoader;
-import com.swmansion.common.GestureHandlerStateManager;
-import com.swmansion.reanimated.keyboardObserver.ReanimatedKeyboardEventListener;
 import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
 import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
 import com.swmansion.reanimated.layoutReanimation.NativeMethodsHolder;
-import com.swmansion.reanimated.sensor.ReanimatedSensorContainer;
-import com.swmansion.reanimated.sensor.ReanimatedSensorType;
+import com.swmansion.reanimated.nativeProxy.NativeProxyCommon;
+
 import java.lang.ref.WeakReference;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-public class NativeProxy {
-
-  static {
-    SoLoader.loadLibrary("reanimated");
-  }
-
-  @DoNotStrip
-  public static class AnimationFrameCallback implements NodesManager.OnAnimationFrame {
-
-    @DoNotStrip private final HybridData mHybridData;
 
+public class NativeProxy extends NativeProxyCommon {
     @DoNotStrip
-    private AnimationFrameCallback(HybridData hybridData) {
-      mHybridData = hybridData;
+    @SuppressWarnings("unused")
+    private final HybridData mHybridData;
+
+    public NativeProxy(ReactApplicationContext context) {
+        super(context);
+
+        CallInvokerHolderImpl holder =
+                (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
+
+        FabricUIManager fabricUIManager =
+                (FabricUIManager) UIManagerHelper.getUIManager(context, UIManagerType.FABRIC);
+
+        LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
+
+        mHybridData =
+                initHybrid(
+                        context.getJavaScriptContextHolder().get(),
+                        holder,
+                        mScheduler,
+                        LayoutAnimations,
+                        fabricUIManager);
+        prepareLayoutAnimations(LayoutAnimations);
+        ReanimatedMessageQueueThread messageQueueThread = new ReanimatedMessageQueueThread();
+        installJSIBindings(messageQueueThread, fabricUIManager);
     }
 
-    @Override
-    public native void onAnimationFrame(double timestampMs);
-  }
-
-  @DoNotStrip
-  public static class EventHandler implements RCTEventEmitter {
+    private native HybridData initHybrid(
+            long jsContext,
+            CallInvokerHolderImpl jsCallInvokerHolder,
+            Scheduler scheduler,
+            LayoutAnimations LayoutAnimations,
+            FabricUIManager fabricUIManager);
 
-    @DoNotStrip private final HybridData mHybridData;
-    private UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
-
-    @DoNotStrip
-    private EventHandler(HybridData hybridData) {
-      mHybridData = hybridData;
-    }
+    private native void installJSIBindings(
+            MessageQueueThread messageQueueThread,
+            FabricUIManager fabricUIManager);
 
-    @Override
-    public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
-      String resolvedEventName = mCustomEventNamesResolver.resolveCustomEventName(eventName);
-      receiveEvent(targetTag + resolvedEventName, event);
-    }
+    public native boolean isAnyHandlerWaitingForEvent(String eventName);
 
-    public native void receiveEvent(String eventKey, @Nullable WritableMap event);
+    public native void performOperations();
 
     @Override
-    public void receiveTouches(
-        String eventName, WritableArray touches, WritableArray changedIndices) {
-      // not interested in processing touch events this way, we process raw events only
-    }
-  }
-
-  @DoNotStrip
-  public static class SensorSetter {
-
-    @DoNotStrip private final HybridData mHybridData;
-
-    @DoNotStrip
-    private SensorSetter(HybridData hybridData) {
-      mHybridData = hybridData;
-    }
-
-    public native void sensorSetter(float[] value);
-  }
-
-  @DoNotStrip
-  public static class KeyboardEventDataUpdater {
-    @DoNotStrip private final HybridData mHybridData;
-
-    @DoNotStrip
-    private KeyboardEventDataUpdater(HybridData hybridData) {
-      mHybridData = hybridData;
-    }
-
-    public native void keyboardEventDataUpdater(int keyboardState, int height);
-  }
-
-  @DoNotStrip
-  @SuppressWarnings("unused")
-  private final HybridData mHybridData;
-
-  private NodesManager mNodesManager;
-  private final WeakReference<ReactApplicationContext> mContext;
-  private Scheduler mScheduler = null;
-  private ReanimatedSensorContainer reanimatedSensorContainer;
-  private final GestureHandlerStateManager gestureHandlerStateManager;
-  private ReanimatedKeyboardEventListener reanimatedKeyboardEventListener;
-  private Long firstUptime = SystemClock.uptimeMillis();
-  private boolean slowAnimationsEnabled = false;
-
-  public NativeProxy(ReactApplicationContext context) {
-    CallInvokerHolderImpl holder =
-        (CallInvokerHolderImpl) context.getCatalystInstance().getJSCallInvokerHolder();
-    LayoutAnimations LayoutAnimations = new LayoutAnimations(context);
-    mScheduler = new Scheduler(context);
-    FabricUIManager fabricUIManager =
-        (FabricUIManager) UIManagerHelper.getUIManager(context, UIManagerType.FABRIC);
-
-    mHybridData =
-        initHybrid(
-            context.getJavaScriptContextHolder().get(),
-            holder,
-            mScheduler,
-            LayoutAnimations,
-            fabricUIManager);
-    mContext = new WeakReference<>(context);
-    prepare(LayoutAnimations);
-    reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
-    reanimatedKeyboardEventListener = new ReanimatedKeyboardEventListener(mContext);
-    addDevMenuOption();
-
-    GestureHandlerStateManager tempHandlerStateManager;
-    try {
-      Class<NativeModule> gestureHandlerModuleClass =
-          (Class<NativeModule>)
-              Class.forName("com.swmansion.gesturehandler.react.RNGestureHandlerModule");
-      tempHandlerStateManager =
-          (GestureHandlerStateManager) context.getNativeModule(gestureHandlerModuleClass);
-    } catch (ClassCastException | ClassNotFoundException e) {
-      tempHandlerStateManager = null;
+    protected HybridData getHybridData() {
+        return mHybridData;
     }
-    gestureHandlerStateManager = tempHandlerStateManager;
-  }
 
-  private native HybridData initHybrid(
-      long jsContext,
-      CallInvokerHolderImpl jsCallInvokerHolder,
-      Scheduler scheduler,
-      LayoutAnimations LayoutAnimations,
-      FabricUIManager fabricUIManager);
+    public static NativeMethodsHolder createNativeMethodsHolder(LayoutAnimations layoutAnimations) {
+        return new NativeMethodsHolder() {
+            @Override
+            public void startAnimation(int tag, int type, HashMap<String, Object> values) {}
 
-  private native void installJSIBindings(
-    MessageQueueThread messageQueueThread,
-    FabricUIManager fabricUIManager);
-
-  public native boolean isAnyHandlerWaitingForEvent(String eventName);
-
-  public native void performOperations();
-
-  public Scheduler getScheduler() {
-    return mScheduler;
-  }
-
-  private void toggleSlowAnimations() {
-    slowAnimationsEnabled = !slowAnimationsEnabled;
-    if (slowAnimationsEnabled) {
-      firstUptime = SystemClock.uptimeMillis();
-    }
-  }
-
-  private void addDevMenuOption() {
-    // In Expo, `ApplicationContext` is not an instance of `ReactApplication`
-    if (mContext.get().getApplicationContext() instanceof ReactApplication) {
-      final DevSupportManager devSupportManager =
-          ((ReactApplication) mContext.get().getApplicationContext())
-              .getReactNativeHost()
-              .getReactInstanceManager()
-              .getDevSupportManager();
-
-      devSupportManager.addCustomDevOption(
-          "Toggle slow animations (Reanimated)", this::toggleSlowAnimations);
-    }
-  }
-
-  @DoNotStrip
-  private void requestRender(AnimationFrameCallback callback) {
-    mNodesManager.postOnAnimation(callback);
-  }
-
-  @DoNotStrip
-  private void updateProps(int viewTag, Map<String, Object> props) {
-    mNodesManager.updateProps(viewTag, props);
-  }
-
-  @DoNotStrip
-  private void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
-    mNodesManager.synchronouslyUpdateUIProps(viewTag, uiProps);
-  }
-
-  @DoNotStrip
-  private String obtainProp(int viewTag, String propName) {
-    return mNodesManager.obtainProp(viewTag, propName);
-  }
-
-  @DoNotStrip
-  private void scrollTo(int viewTag, double x, double y, boolean animated) {
-    mNodesManager.scrollTo(viewTag, x, y, animated);
-  }
-
-  @DoNotStrip
-  private void setGestureState(int handlerTag, int newState) {
-    if (gestureHandlerStateManager != null) {
-      gestureHandlerStateManager.setGestureHandlerState(handlerTag, newState);
-    }
-  }
-
-  @DoNotStrip
-  private long getCurrentTime() {
-    if (slowAnimationsEnabled) {
-      final long ANIMATIONS_DRAG_FACTOR = 10;
-      return this.firstUptime + (SystemClock.uptimeMillis() - this.firstUptime) / ANIMATIONS_DRAG_FACTOR;
-    } else {
-      return SystemClock.uptimeMillis();
-    }
-  }
-
-  @DoNotStrip
-  private float[] measure(int viewTag) {
-    return mNodesManager.measure(viewTag);
-  }
-
-  @DoNotStrip
-  private void configureProps(ReadableNativeArray uiProps, ReadableNativeArray nativeProps) {
-    Set<String> uiPropsSet = convertProps(uiProps);
-    Set<String> nativePropsSet = convertProps(nativeProps);
-    mNodesManager.configureProps(uiPropsSet, nativePropsSet);
-  }
-
-  private Set<String> convertProps(ReadableNativeArray props) {
-    Set<String> propsSet = new HashSet<>();
-    ArrayList<Object> propsList = props.toArrayList();
-    for (int i = 0; i < propsList.size(); i++) {
-      propsSet.add((String) propsList.get(i));
-    }
-    return propsSet;
-  }
-
-  @DoNotStrip
-  private void registerEventHandler(EventHandler handler) {
-    handler.mCustomEventNamesResolver = mNodesManager.getEventNameResolver();
-    mNodesManager.registerEventHandler(handler);
-  }
-
-  @DoNotStrip
-  private int registerSensor(int sensorType, int interval, SensorSetter setter) {
-    return reanimatedSensorContainer.registerSensor(
-        ReanimatedSensorType.getInstanceById(sensorType), interval, setter);
-  }
-
-  @DoNotStrip
-  private void unregisterSensor(int sensorId) {
-    reanimatedSensorContainer.unregisterSensor(sensorId);
-  }
-
-  @DoNotStrip
-  private int subscribeForKeyboardEvents(KeyboardEventDataUpdater keyboardEventDataUpdater) {
-    return reanimatedKeyboardEventListener.subscribeForKeyboardEvents(keyboardEventDataUpdater);
-  }
-
-  @DoNotStrip
-  private void unsubscribeFromKeyboardEvents(int listenerId) {
-    reanimatedKeyboardEventListener.unsubscribeFromKeyboardEvents(listenerId);
-  }
-
-  public void onCatalystInstanceDestroy() {
-    mScheduler.deactivate();
-    mHybridData.resetNative();
-  }
-
-  public void prepare(LayoutAnimations LayoutAnimations) {
-    if (Utils.isChromeDebugger) {
-      Log.w("[REANIMATED]", "You can not use LayoutAnimation with enabled Chrome Debugger");
-      return;
-    }
-    mNodesManager = mContext.get().getNativeModule(ReanimatedModule.class).getNodesManager();
-    FabricUIManager fabricUIManager =
-      (FabricUIManager) UIManagerHelper.getUIManager(mContext.get(), UIManagerType.FABRIC);
-    ReanimatedMessageQueueThread messageQueueThread = new ReanimatedMessageQueueThread();
-    installJSIBindings(messageQueueThread, fabricUIManager);
-    AnimationsManager animationsManager =
-        mContext
-            .get()
-            .getNativeModule(ReanimatedModule.class)
-            .getNodesManager()
-            .getAnimationsManager();
+            @Override
+            public boolean isLayoutAnimationEnabled() {
+                return false;
+            }
 
-    WeakReference<LayoutAnimations> weakLayoutAnimations = new WeakReference<>(LayoutAnimations);
-    animationsManager.setNativeMethods(
-            new NativeMethodsHolder() {
-              @Override
-              public void startAnimation(int tag, String type, HashMap<String, Float> values) {}
+            @Override
+            public int findPrecedingViewTagForTransition(int tag) {
+                return -1;
+            }
 
-              @Override
-              public boolean isLayoutAnimationEnabled() {
+            @Override
+            public boolean hasAnimation(int tag, int type) {
                 return false;
-              }
+            }
 
-              @Override
-              public boolean hasAnimation(int tag, String type) {
-                return false;
-              }
+            @Override
+            public void clearAnimationConfig(int tag) {}
 
-              @Override
-              public void clearAnimationConfig(int tag) {}
-            });
-  }
+            @Override
+            public void cancelAnimation(int tag, int type, boolean cancelled, boolean removeView) {}
+        };
+    }
 }

package/android/src/main/cpp/LayoutAnimations.cpp

@@ -20,19 +20,20 @@ void LayoutAnimations::setAnimationStartingBlock(
 
 void LayoutAnimations::startAnimationForTag(
     int tag,
-    alias_ref<JString> type,
+    int type,
     alias_ref<JMap<jstring, jstring>> values) {
   this->animationStartingBlock_(tag, type, values);
 }
 
 void LayoutAnimations::progressLayoutAnimation(
     int tag,
-    const jni::local_ref<JNIHelper::PropsMap> &updates) {
+    const jni::local_ref<JNIHelper::PropsMap> &updates,
+    bool isSharedTransition) {
   static const auto method =
       javaPart_->getClass()
-          ->getMethod<void(int, JMap<JString, JObject>::javaobject)>(
+          ->getMethod<void(int, JMap<JString, JObject>::javaobject, bool)>(
               "progressLayoutAnimation");
-  method(javaPart_.get(), tag, updates.get());
+  method(javaPart_.get(), tag, updates.get(), isSharedTransition);
 }
 
 void LayoutAnimations::endLayoutAnimation(
@@ -50,7 +51,7 @@ void LayoutAnimations::setHasAnimationBlock(
   this->hasAnimationBlock_ = hasAnimationBlock;
 }
 
-bool LayoutAnimations::hasAnimationForTag(int tag, std::string type) {
+bool LayoutAnimations::hasAnimationForTag(int tag, int type) {
   return hasAnimationBlock_(tag, type);
 }
 
@@ -63,10 +64,34 @@ void LayoutAnimations::clearAnimationConfigForTag(int tag) {
   clearAnimationConfigBlock_(tag);
 }
 
+void LayoutAnimations::setCancelAnimationForTag(
+    CancelAnimationBlock cancelAnimationBlock) {
+  this->cancelAnimationBlock_ = cancelAnimationBlock;
+}
+
+void LayoutAnimations::cancelAnimationForTag(
+    int tag,
+    int type,
+    jboolean cancelled,
+    jboolean removeView) {
+  this->cancelAnimationBlock_(tag, type, cancelled, removeView);
+}
+
 bool LayoutAnimations::isLayoutAnimationEnabled() {
   return FeaturesConfig::isLayoutAnimationEnabled();
 }
 
+void LayoutAnimations::setFindPrecedingViewTagForTransition(
+    FindPrecedingViewTagForTransitionBlock
+        findPrecedingViewTagForTransitionBlock) {
+  findPrecedingViewTagForTransitionBlock_ =
+      findPrecedingViewTagForTransitionBlock;
+}
+
+int LayoutAnimations::findPrecedingViewTagForTransition(int tag) {
+  return findPrecedingViewTagForTransitionBlock_(tag);
+}
+
 void LayoutAnimations::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", LayoutAnimations::initHybrid),
@@ -77,9 +102,14 @@ void LayoutAnimations::registerNatives() {
       makeNativeMethod(
           "clearAnimationConfigForTag",
           LayoutAnimations::clearAnimationConfigForTag),
+      makeNativeMethod(
+          "cancelAnimationForTag", LayoutAnimations::cancelAnimationForTag),
       makeNativeMethod(
           "isLayoutAnimationEnabled",
           LayoutAnimations::isLayoutAnimationEnabled),
+      makeNativeMethod(
+          "findPrecedingViewTagForTransition",
+          LayoutAnimations::findPrecedingViewTagForTransition),
   });
 }
 }; // namespace reanimated

package/android/src/main/cpp/LayoutAnimations.h

@@ -12,10 +12,13 @@ using namespace facebook::jni;
 using namespace facebook;
 
 class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
-  using AnimationStartingBlock = std::function<
-      void(int, alias_ref<JString>, alias_ref<JMap<jstring, jstring>>)>;
-  using HasAnimationBlock = std::function<bool(int, const std::string &)>;
+  using AnimationStartingBlock =
+      std::function<void(int, int, alias_ref<JMap<jstring, jstring>>)>;
+  using HasAnimationBlock = std::function<bool(int, int)>;
   using ClearAnimationConfigBlock = std::function<void(int)>;
+  using CancelAnimationBlock =
+      std::function<void(int, int, jboolean, jboolean)>;
+  using FindPrecedingViewTagForTransitionBlock = std::function<int(int)>;
 
  public:
   static auto constexpr kJavaDescriptor =
@@ -26,21 +29,32 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
 
   void startAnimationForTag(
       int tag,
-      alias_ref<JString> type,
+      int type,
       alias_ref<JMap<jstring, jstring>> values);
-  bool hasAnimationForTag(int tag, std::string type);
+  bool hasAnimationForTag(int tag, int type);
   bool isLayoutAnimationEnabled();
 
   void setAnimationStartingBlock(AnimationStartingBlock animationStartingBlock);
   void setHasAnimationBlock(HasAnimationBlock hasAnimationBlock);
   void setClearAnimationConfigBlock(
       ClearAnimationConfigBlock clearAnimationConfigBlock);
+  void setCancelAnimationForTag(CancelAnimationBlock cancelAnimationBlock);
+  void setFindPrecedingViewTagForTransition(
+      FindPrecedingViewTagForTransitionBlock
+          findPrecedingViewTagForTransitionBlock);
 
   void progressLayoutAnimation(
       int tag,
-      const jni::local_ref<JNIHelper::PropsMap> &updates);
+      const jni::local_ref<JNIHelper::PropsMap> &updates,
+      bool isSharedTransition);
   void endLayoutAnimation(int tag, bool cancelled, bool removeView);
   void clearAnimationConfigForTag(int tag);
+  void cancelAnimationForTag(
+      int tag,
+      int type,
+      jboolean cancelled,
+      jboolean removeView);
+  int findPrecedingViewTagForTransition(int tag);
 
  private:
   friend HybridBase;
@@ -48,6 +62,9 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
   AnimationStartingBlock animationStartingBlock_;
   HasAnimationBlock hasAnimationBlock_;
   ClearAnimationConfigBlock clearAnimationConfigBlock_;
+  CancelAnimationBlock cancelAnimationBlock_;
+  FindPrecedingViewTagForTransitionBlock
+      findPrecedingViewTagForTransitionBlock_;
 
   explicit LayoutAnimations(
       jni::alias_ref<LayoutAnimations::jhybridobject> jThis);