react-native-reanimated 3.0.0-rc.8 → 3.0.0

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

@@ -1,6 +1,8 @@
 package com.swmansion.reanimated.layoutReanimation;
 
 import android.app.Activity;
+import android.graphics.Point;
+import android.graphics.Rect;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.View;
@@ -10,6 +12,7 @@ import com.facebook.react.bridge.JavaOnlyMap;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableNativeArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.IViewManagerWithChildren;
 import com.facebook.react.uimanager.IllegalViewOperationException;
@@ -24,6 +27,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import javax.annotation.Nullable;
 
 public class AnimationsManager implements ViewHierarchyObserver {
   private WeakReference<Scheduler> mScheduler;
@@ -31,12 +35,15 @@ public class AnimationsManager implements ViewHierarchyObserver {
   private UIManagerModule mUIManager;
   private NativeMethodsHolder mNativeMethodsHolder;
 
+  private HashSet<Integer> mEnteringViews = new HashSet<>();
+  private HashMap<Integer, Rect> mEnteringViewTargetValues = new HashMap<>();
   private HashMap<Integer, View> mExitingViews = new HashMap<>();
   private HashMap<Integer, Integer> mExitingSubviewCountMap = new HashMap<>();
   private HashSet<Integer> mAncestorsToRemove = new HashSet<>();
   private HashMap<Integer, Runnable> mCallbacks = new HashMap<>();
   private ReanimatedNativeHierarchyManager mReanimatedNativeHierarchyManager;
   private boolean isCatalystInstanceDestroyed;
+  private SharedTransitionManager mSharedTransitionManager;
 
   public void setReanimatedNativeHierarchyManager(
       ReanimatedNativeHierarchyManager reanimatedNativeHierarchyManager) {
@@ -55,6 +62,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
     mContext = context;
     mUIManager = uiManagerModule;
     isCatalystInstanceDestroyed = false;
+    mSharedTransitionManager = new SharedTransitionManager(this);
   }
 
   public void onCatalystInstanceDestroy() {
@@ -86,8 +94,9 @@ public class AnimationsManager implements ViewHierarchyObserver {
     if (isCatalystInstanceDestroyed) {
       return;
     }
+    maybeRegisterSharedView(view);
 
-    if (!hasAnimationForTag(view.getId(), "entering")) {
+    if (!hasAnimationForTag(view.getId(), LayoutAnimations.Types.ENTERING)) {
       return;
     }
 
@@ -99,8 +108,9 @@ public class AnimationsManager implements ViewHierarchyObserver {
     HashMap<String, Object> targetValues = after.toTargetMap();
 
     if (targetValues != null) {
-      HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(targetValues, true);
-      mNativeMethodsHolder.startAnimation(tag, "entering", preparedValues);
+      HashMap<String, Object> preparedValues = prepareDataForAnimationWorklet(targetValues, true);
+      mNativeMethodsHolder.startAnimation(tag, LayoutAnimations.Types.ENTERING, preparedValues);
+      mEnteringViews.add(tag);
     }
   }
 
@@ -111,12 +121,29 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
     int tag = view.getId();
 
-    if (!hasAnimationForTag(tag, "layout")) {
+    if (!hasAnimationForTag(tag, LayoutAnimations.Types.LAYOUT)) {
+      if (mEnteringViews.contains(tag)) {
+        // store values to restore after `entering` finishes
+        mEnteringViewTargetValues.put(
+            tag,
+            new Rect(
+                after.originX,
+                after.originY,
+                after.originX + after.width,
+                after.originY + after.height));
+        // restore layout before the update, so the `entering`
+        // can continue from its current location
+        view.layout(
+            before.originX,
+            before.originY,
+            before.originX + before.width,
+            before.originY + before.height);
+      }
       return;
     }
 
-    HashMap<String, Object> targetValues = after.toTargetMap();
     HashMap<String, Object> startValues = before.toCurrentMap();
+    HashMap<String, Object> targetValues = after.toTargetMap();
 
     // If startValues are equal to targetValues it means that there was no UI Operation changing
     // layout of the View. So dirtiness of that View is false positive
@@ -135,17 +162,25 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
 
     // View must be in Layout state
-    HashMap<String, Float> preparedStartValues = prepareDataForAnimationWorklet(startValues, false);
-    HashMap<String, Float> preparedTargetValues =
+    HashMap<String, Object> preparedStartValues =
+        prepareDataForAnimationWorklet(startValues, false);
+    HashMap<String, Object> preparedTargetValues =
         prepareDataForAnimationWorklet(targetValues, true);
-    HashMap<String, Float> preparedValues = new HashMap<>(preparedTargetValues);
+    HashMap<String, Object> preparedValues = new HashMap<>(preparedTargetValues);
     for (String key : preparedStartValues.keySet()) {
       preparedValues.put(key, preparedStartValues.get(key));
     }
-    mNativeMethodsHolder.startAnimation(tag, "layout", preparedValues);
+    mNativeMethodsHolder.startAnimation(tag, LayoutAnimations.Types.LAYOUT, preparedValues);
+  }
+
+  public void maybeRegisterSharedView(View view) {
+    if (hasAnimationForTag(view.getId(), LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION)) {
+      mSharedTransitionManager.notifyAboutNewView(view);
+    }
   }
 
-  public void progressLayoutAnimation(int tag, Map<String, Object> newStyle) {
+  public void progressLayoutAnimation(
+      int tag, Map<String, Object> newStyle, boolean isSharedTransition) {
     View view = resolveView(tag);
 
     if (view == null) {
@@ -161,24 +196,39 @@ public class AnimationsManager implements ViewHierarchyObserver {
     ViewManager viewManager = resolveViewManager(tag);
     ViewManager parentViewManager = resolveViewManager(parent.getId());
 
-    setNewProps(newStyle, view, viewManager, parentViewManager, parent.getId());
+    if (viewManager == null) {
+      return;
+    }
+
+    setNewProps(newStyle, view, viewManager, parentViewManager, parent.getId(), isSharedTransition);
   }
 
   public void endLayoutAnimation(int tag, boolean cancelled, boolean removeView) {
-    View exitingView = mExitingViews.get(tag);
-    if (exitingView != null && removeView) {
-      if (exitingView instanceof ViewGroup && mAncestorsToRemove.contains(tag)) {
-        cancelAnimationsInSubviews((ViewGroup) exitingView);
+    View view = resolveView(tag);
+
+    if (view == null) {
+      return;
+    }
+
+    Rect target = mEnteringViewTargetValues.get(tag);
+    if (!removeView && mEnteringViews.contains(tag) && target != null) {
+      view.layout(target.left, target.top, target.right, target.bottom);
+    }
+    mEnteringViews.remove(tag);
+    mEnteringViewTargetValues.remove(tag);
+
+    if (removeView) {
+      if (view instanceof ViewGroup && mAncestorsToRemove.contains(tag)) {
+        cancelAnimationsInSubviews((ViewGroup) view);
       }
 
       mExitingViews.remove(tag);
-      maybeDropAncestors(exitingView);
+      maybeDropAncestors(view);
 
-      ViewGroup parent = (ViewGroup) exitingView.getParent();
-      if (parent != null) {
-        removeView(exitingView, parent);
-      }
+      ViewGroup parent = (ViewGroup) view.getParent();
+      removeView(view, parent);
     }
+    mSharedTransitionManager.finishSharedAnimation(tag);
   }
 
   public void printSubTree(View view, int level) {
@@ -205,9 +255,14 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
   }
 
-  public HashMap<String, Float> prepareDataForAnimationWorklet(
+  public HashMap<String, Object> prepareDataForAnimationWorklet(
       HashMap<String, Object> values, boolean isTargetValues) {
-    HashMap<String, Float> preparedValues = new HashMap<>();
+    return prepareDataForAnimationWorklet(values, isTargetValues, false);
+  }
+
+  public HashMap<String, Object> prepareDataForAnimationWorklet(
+      HashMap<String, Object> values, boolean isTargetValues, boolean addTransform) {
+    HashMap<String, Object> preparedValues = new HashMap<>();
     ArrayList<String> keys;
     if (isTargetValues) {
       keys = Snapshot.targetKeysToTransform;
@@ -218,6 +273,12 @@ public class AnimationsManager implements ViewHierarchyObserver {
       preparedValues.put(key, PixelUtil.toDIPFromPixel((int) values.get(key)));
     }
 
+    if (addTransform) {
+      String key =
+          isTargetValues ? Snapshot.TARGET_TRANSFORM_MATRIX : Snapshot.CURRENT_TRANSFORM_MATRIX;
+      preparedValues.put(key, values.get(key));
+    }
+
     DisplayMetrics displayMetrics = new DisplayMetrics();
     Activity currentActivity = mContext.getCurrentActivity();
     if (currentActivity != null) {
@@ -235,6 +296,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
 
   public void setNativeMethods(NativeMethodsHolder nativeMethods) {
     mNativeMethodsHolder = nativeMethods;
+    mSharedTransitionManager.setNativeMethods(nativeMethods);
   }
 
   public void setNewProps(
@@ -242,7 +304,8 @@ public class AnimationsManager implements ViewHierarchyObserver {
       View view,
       ViewManager viewManager,
       ViewManager parentViewManager,
-      Integer parentTag) {
+      Integer parentTag,
+      boolean isPositionAbsolute) {
     float x =
         (props.get(Snapshot.ORIGIN_X) != null)
             ? ((Double) props.get(Snapshot.ORIGIN_X)).floatValue()
@@ -259,9 +322,37 @@ public class AnimationsManager implements ViewHierarchyObserver {
         (props.get(Snapshot.HEIGHT) != null)
             ? ((Double) props.get(Snapshot.HEIGHT)).floatValue()
             : PixelUtil.toDIPFromPixel(view.getHeight());
-    updateLayout(view, parentViewManager, parentTag, view.getId(), x, y, width, height);
+
+    if (props.containsKey(Snapshot.TRANSFORM_MATRIX)) {
+      float[] matrixValues = new float[9];
+      if (props.get(Snapshot.TRANSFORM_MATRIX) instanceof ReadableNativeArray) {
+        // this array comes from JavaScript
+        ReadableNativeArray matrixArray =
+            (ReadableNativeArray) props.get(Snapshot.TRANSFORM_MATRIX);
+        for (int i = 0; i < 9; i++) {
+          matrixValues[i] = ((Double) matrixArray.getDouble(i)).floatValue();
+        }
+      } else {
+        // this array comes from Java
+        ArrayList<Float> casted = (ArrayList<Float>) props.get(Snapshot.TRANSFORM_MATRIX);
+        for (int i = 0; i < 9; i++) {
+          matrixValues[i] = casted.get(i);
+        }
+      }
+      view.setScaleX(matrixValues[0]);
+      view.setScaleY(matrixValues[4]);
+      // as far, let's support only scale and translation. Rotation maybe the future feature
+      // (http://eecs.qmul.ac.uk/~gslabaugh/publications/euler.pdf)
+
+      props.remove(Snapshot.TRANSFORM_MATRIX);
+    }
+
+    updateLayout(
+        view, parentViewManager, parentTag, view.getId(), x, y, width, height, isPositionAbsolute);
     props.remove(Snapshot.ORIGIN_X);
     props.remove(Snapshot.ORIGIN_Y);
+    props.remove(Snapshot.GLOBAL_ORIGIN_X);
+    props.remove(Snapshot.GLOBAL_ORIGIN_Y);
     props.remove(Snapshot.WIDTH);
     props.remove(Snapshot.HEIGHT);
 
@@ -307,7 +398,8 @@ public class AnimationsManager implements ViewHierarchyObserver {
       float xf,
       float yf,
       float widthf,
-      float heightf) {
+      float heightf,
+      boolean isPositionAbsolute) {
 
     int x = Math.round(PixelUtil.toPixelFromDIP(xf));
     int y = Math.round(PixelUtil.toPixelFromDIP(yf));
@@ -348,7 +440,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
 
     // Check if the parent of the view has to layout the view, or the child has to lay itself out.
-    if (parentTag % 10 == 1) { // ParentIsARoot
+    if (parentTag % 10 == 1 && parentViewManager != null) { // parentTag % 10 == 1 - ParentIsARoot
       IViewManagerWithChildren parentViewManagerWithChildren;
       if (parentViewManager instanceof IViewManagerWithChildren) {
         parentViewManagerWithChildren = (IViewManagerWithChildren) parentViewManager;
@@ -362,11 +454,18 @@ public class AnimationsManager implements ViewHierarchyObserver {
         viewToUpdate.layout(x, y, x + width, y + height);
       }
     } else {
+      if (isPositionAbsolute) {
+        Point newPoint = new Point(x, y);
+        View viewToUpdateParent = (View) viewToUpdate.getParent();
+        Point convertedPoint = convertScreenLocationToViewCoordinates(newPoint, viewToUpdateParent);
+        x = convertedPoint.x;
+        y = convertedPoint.y;
+      }
       viewToUpdate.layout(x, y, x + width, y + height);
     }
   }
 
-  public boolean hasAnimationForTag(int tag, String type) {
+  public boolean hasAnimationForTag(int tag, int type) {
     return mNativeMethodsHolder.hasAnimation(tag, type);
   }
 
@@ -376,10 +475,23 @@ public class AnimationsManager implements ViewHierarchyObserver {
 
   private boolean removeOrAnimateExitRecursive(View view, ViewGroup parent, boolean shouldRemove) {
     int tag = view.getId();
-    boolean hasExitAnimation = hasAnimationForTag(tag, "exiting") || mExitingViews.containsKey(tag);
+    ViewManager viewManager = resolveViewManager(tag);
+
+    if (viewManager != null && viewManager.getName().equals("RNSScreenStack")) {
+      cancelAnimationsRecursive(view);
+      return false;
+    }
+
+    boolean hasExitAnimation =
+        hasAnimationForTag(tag, LayoutAnimations.Types.EXITING) || mExitingViews.containsKey(tag);
     boolean hasAnimatedChildren = false;
     shouldRemove = shouldRemove && !hasExitAnimation;
 
+    if (hasAnimationForTag(tag, LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION)) {
+      mSharedTransitionManager.notifyAboutRemovedView(view);
+      mSharedTransitionManager.makeSnapshot(view);
+    }
+
     ArrayList<View> toBeRemoved = new ArrayList<>();
 
     // we might want to keep this view around
@@ -402,11 +514,11 @@ public class AnimationsManager implements ViewHierarchyObserver {
     if (hasExitAnimation) {
       Snapshot before = new Snapshot(view, mReanimatedNativeHierarchyManager);
       HashMap<String, Object> currentValues = before.toCurrentMap();
-      HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(currentValues, false);
+      HashMap<String, Object> preparedValues = prepareDataForAnimationWorklet(currentValues, false);
       if (!mExitingViews.containsKey(tag)) {
         mExitingViews.put(tag, view);
         registerExitingAncestors(view);
-        mNativeMethodsHolder.startAnimation(tag, "exiting", preparedValues);
+        mNativeMethodsHolder.startAnimation(tag, LayoutAnimations.Types.EXITING, preparedValues);
       }
     }
 
@@ -427,6 +539,28 @@ public class AnimationsManager implements ViewHierarchyObserver {
     return true;
   }
 
+  public void clearAnimationConfigForTag(int tag) {
+    View view = resolveView(tag);
+    if (view != null) {
+      clearAnimationConfigRecursive(view);
+    }
+  }
+
+  public void clearAnimationConfigRecursive(View view) {
+    mNativeMethodsHolder.clearAnimationConfig(view.getId());
+    if (view instanceof ViewGroup) {
+      ViewGroup viewGroup = (ViewGroup) view;
+      for (int i = 0; i < viewGroup.getChildCount(); i++) {
+        clearAnimationConfigRecursive(viewGroup.getChildAt(i));
+      }
+    }
+  }
+
+  public void cancelAnimationsInSubviews(View view) {
+    cancelAnimationsRecursive(view);
+    clearAnimationConfigRecursive(view);
+  }
+
   private void registerExitingAncestors(View view) {
     View parent = (View) view.getParent();
     while (parent != null && !(parent instanceof RootView)) {
@@ -440,6 +574,9 @@ public class AnimationsManager implements ViewHierarchyObserver {
   }
 
   private void maybeDropAncestors(View exitingView) {
+    if (!(exitingView.getParent() instanceof View)) {
+      return;
+    }
     View parent = (View) exitingView.getParent();
     while (parent != null && !(parent instanceof RootView)) {
       View view = parent;
@@ -461,7 +598,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
   }
 
-  private void removeView(View view, ViewGroup parent) {
+  private void removeView(View view, @Nullable ViewGroup parent) {
     int tag = view.getId();
     if (mCallbacks.containsKey(tag)) {
       Runnable callback = mCallbacks.get(tag);
@@ -473,16 +610,30 @@ public class AnimationsManager implements ViewHierarchyObserver {
       mReanimatedNativeHierarchyManager.publicDropView(view);
     }
 
-    parent.removeView(view);
+    if (parent != null) {
+      parent.removeView(view);
+    }
+  }
+
+  public void cancelAnimationsRecursive(View view) {
+    if (mExitingViews.containsKey(view.getId())) {
+      endLayoutAnimation(view.getId(), true, true);
+    } else if (view instanceof ViewGroup && mExitingSubviewCountMap.containsKey(view.getId())) {
+      cancelAnimationsInSubviews((ViewGroup) view);
+    }
   }
 
   private void cancelAnimationsInSubviews(ViewGroup view) {
     for (int i = view.getChildCount() - 1; i >= 0; i--) {
       View child = view.getChildAt(i);
 
+      if (child == null) {
+        continue;
+      }
+
       if (mExitingViews.containsKey(child.getId())) {
         endLayoutAnimation(child.getId(), true, true);
-      } else if (child instanceof ViewGroup && mAncestorsToRemove.contains(child.getId())) {
+      } else if (child instanceof ViewGroup && mExitingSubviewCountMap.containsKey(child.getId())) {
         cancelAnimationsInSubviews((ViewGroup) child);
       }
     }
@@ -491,12 +642,17 @@ public class AnimationsManager implements ViewHierarchyObserver {
   private View resolveView(int tag) {
     if (mExitingViews.containsKey(tag)) {
       return mExitingViews.get(tag);
+    } else {
+      View view = mSharedTransitionManager.getTransitioningView(tag);
+      if (view != null) {
+        return view;
+      }
     }
+
     try {
       return mUIManager.resolveView(tag);
     } catch (IllegalViewOperationException e) {
       // view has been removed already
-      e.printStackTrace();
       return null;
     }
   }
@@ -505,8 +661,35 @@ public class AnimationsManager implements ViewHierarchyObserver {
     try {
       return mReanimatedNativeHierarchyManager.resolveViewManager(tag);
     } catch (Exception e) {
-      e.printStackTrace();
       return null;
     }
   }
+
+  private static Point convertScreenLocationToViewCoordinates(Point fromPoint, View parentView) {
+    int[] toPoint = {0, 0};
+    if (parentView != null) {
+      parentView.getLocationOnScreen(toPoint);
+    }
+    return new Point(fromPoint.x - toPoint[0], fromPoint.y - toPoint[1]);
+  }
+
+  public void screenDidLayout() {
+    mSharedTransitionManager.screenDidLayout();
+  }
+
+  public void viewDidLayout(View view) {
+    mSharedTransitionManager.viewDidLayout(view);
+  }
+
+  public void notifyAboutViewsRemoval(int[] tagsToDelete) {
+    mSharedTransitionManager.onViewsRemoval(tagsToDelete);
+  }
+
+  public void makeSnapshotOfTopScreenViews(ViewGroup stack) {
+    mSharedTransitionManager.doSnapshotForTopScreenViews(stack);
+  }
+
+  protected ReactContext getContext() {
+    return mContext;
+  }
 }

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

@@ -9,6 +9,13 @@ import java.lang.ref.WeakReference;
 import java.util.Map;
 
 public class LayoutAnimations {
+  public static class Types {
+    static final int ENTERING = 1;
+    static final int EXITING = 2;
+    static final int LAYOUT = 3;
+    static final int SHARED_ELEMENT_TRANSITION = 4;
+  }
+
   static {
     SoLoader.loadLibrary("reanimated");
   }
@@ -17,7 +24,8 @@ public class LayoutAnimations {
   @SuppressWarnings("unused")
   private final HybridData mHybridData;
 
-  private WeakReference<ReactApplicationContext> mContext;
+  private final WeakReference<ReactApplicationContext> mContext;
+  private WeakReference<AnimationsManager> mWeakAnimationsManager = new WeakReference<>(null);
 
   public LayoutAnimations(ReactApplicationContext context) {
     mContext = new WeakReference<>(context);
@@ -27,33 +35,51 @@ public class LayoutAnimations {
   private native HybridData initHybrid();
 
   // LayoutReanimation
-  public native void startAnimationForTag(int tag, String type, Map<String, String> values);
+  public native void startAnimationForTag(int tag, int type, Map<String, String> values);
 
-  public native boolean hasAnimationForTag(int tag, String type);
+  public native boolean hasAnimationForTag(int tag, int type);
 
   public native void clearAnimationConfigForTag(int tag);
 
+  public native void cancelAnimationForTag(
+      int tag, int type, boolean cancelled, boolean removeView);
+
   public native boolean isLayoutAnimationEnabled();
 
+  public native int findPrecedingViewTagForTransition(int tag);
+
   private void endLayoutAnimation(int tag, boolean cancelled, boolean removeView) {
-    ReactApplicationContext context = mContext.get();
-    if (context != null) {
-      context
-          .getNativeModule(ReanimatedModule.class)
-          .getNodesManager()
-          .getAnimationsManager()
-          .endLayoutAnimation(tag, cancelled, removeView);
+    AnimationsManager animationsManager = getAnimationsManager();
+    if (animationsManager == null) {
+      return;
+    }
+    animationsManager.endLayoutAnimation(tag, cancelled, removeView);
+  }
+
+  private void progressLayoutAnimation(
+      int tag, Map<String, Object> newStyle, boolean isSharedTransition) {
+    AnimationsManager animationsManager = getAnimationsManager();
+    if (animationsManager == null) {
+      return;
     }
+    animationsManager.progressLayoutAnimation(tag, newStyle, isSharedTransition);
   }
 
-  private void progressLayoutAnimation(int tag, Map<String, Object> newStyle) {
+  private AnimationsManager getAnimationsManager() {
+    AnimationsManager animationsManager = mWeakAnimationsManager.get();
+    if (animationsManager != null) {
+      return mWeakAnimationsManager.get();
+    }
+
     ReactApplicationContext context = mContext.get();
-    if (context != null) {
-      context
-          .getNativeModule(ReanimatedModule.class)
-          .getNodesManager()
-          .getAnimationsManager()
-          .progressLayoutAnimation(tag, newStyle);
+    if (context == null) {
+      return null;
     }
+
+    animationsManager =
+        context.getNativeModule(ReanimatedModule.class).getNodesManager().getAnimationsManager();
+
+    mWeakAnimationsManager = new WeakReference<>(animationsManager);
+    return animationsManager;
   }
 }

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

@@ -3,11 +3,15 @@ package com.swmansion.reanimated.layoutReanimation;
 import java.util.HashMap;
 
 public interface NativeMethodsHolder {
-  void startAnimation(int tag, String type, HashMap<String, Float> values);
+  void startAnimation(int tag, int type, HashMap<String, Object> values);
 
-  boolean hasAnimation(int tag, String type);
+  boolean hasAnimation(int tag, int type);
 
   void clearAnimationConfig(int tag);
 
+  void cancelAnimation(int tag, int type, boolean cancelled, boolean removeView);
+
   boolean isLayoutAnimationEnabled();
+
+  int findPrecedingViewTagForTransition(int tag);
 }

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

@@ -0,0 +1,19 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import android.view.View;
+
+public class SharedElement {
+
+  public View sourceView;
+  public Snapshot sourceViewSnapshot;
+  public View targetView;
+  public Snapshot targetViewSnapshot;
+
+  public SharedElement(
+      View sourceView, Snapshot sourceViewSnapshot, View targetView, Snapshot targetViewSnapshot) {
+    this.sourceView = sourceView;
+    this.sourceViewSnapshot = sourceViewSnapshot;
+    this.targetView = targetView;
+    this.targetViewSnapshot = targetViewSnapshot;
+  }
+}