react-native-reanimated 3.13.0-rc.2 → 3.13.0

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

@@ -1,4 +1,5 @@
 #include "LayoutAnimations.h"
+#include <vector>
 #include "FeaturesConfig.h"
 #include "Logger.h"
 
@@ -100,10 +101,22 @@ void LayoutAnimations::setFindPrecedingViewTagForTransition(
       findPrecedingViewTagForTransitionBlock;
 }
 
+void LayoutAnimations::setGetSharedGroupBlock(
+    GetSharedGroupBlock getSharedGroupBlock) {
+  getSharedGroupBlock_ = getSharedGroupBlock;
+}
+
 int LayoutAnimations::findPrecedingViewTagForTransition(int tag) {
   return findPrecedingViewTagForTransitionBlock_(tag);
 }
 
+jni::local_ref<JArrayInt> LayoutAnimations::getSharedGroup(const int tag) {
+  const auto &group = getSharedGroupBlock_(tag);
+  auto jGroup = JArrayInt::newArray(group.size());
+  jGroup->setRegion(0, group.size(), group.data());
+  return jGroup;
+}
+
 void LayoutAnimations::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", LayoutAnimations::initHybrid),
@@ -124,6 +137,7 @@ void LayoutAnimations::registerNatives() {
       makeNativeMethod(
           "findPrecedingViewTagForTransition",
           LayoutAnimations::findPrecedingViewTagForTransition),
+      makeNativeMethod("getSharedGroup", LayoutAnimations::getSharedGroup),
 #ifndef NDEBUG
       makeNativeMethod(
           "checkDuplicateSharedTag", LayoutAnimations::checkDuplicateSharedTag),

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

@@ -4,6 +4,7 @@
 #include <jsi/jsi.h>
 #include <memory>
 #include <string>
+#include <vector>
 #include "JNIHelper.h"
 
 namespace reanimated {
@@ -22,6 +23,7 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
   using ClearAnimationConfigBlock = std::function<void(int)>;
   using CancelAnimationBlock = std::function<void(int)>;
   using FindPrecedingViewTagForTransitionBlock = std::function<int(int)>;
+  using GetSharedGroupBlock = std::function<std::vector<int>(const int)>;
 
  public:
   static auto constexpr kJavaDescriptor =
@@ -53,6 +55,7 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
   void setFindPrecedingViewTagForTransition(
       FindPrecedingViewTagForTransitionBlock
           findPrecedingViewTagForTransitionBlock);
+  void setGetSharedGroupBlock(const GetSharedGroupBlock getSharedGroupBlock);
 
   void progressLayoutAnimation(
       int tag,
@@ -62,6 +65,7 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
   void clearAnimationConfigForTag(int tag);
   void cancelAnimationForTag(int tag);
   int findPrecedingViewTagForTransition(int tag);
+  jni::local_ref<JArrayInt> getSharedGroup(const int tag);
 
  private:
   friend HybridBase;
@@ -73,6 +77,7 @@ class LayoutAnimations : public jni::HybridClass<LayoutAnimations> {
   CancelAnimationBlock cancelAnimationBlock_;
   FindPrecedingViewTagForTransitionBlock
       findPrecedingViewTagForTransitionBlock_;
+  GetSharedGroupBlock getSharedGroupBlock_;
 #ifndef NDEBUG
   CheckDuplicateSharedTag checkDuplicateSharedTag_;
 #endif

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

@@ -652,6 +652,16 @@ void NativeProxy::setupLayoutAnimations() {
           return -1;
         }
       });
+
+  layoutAnimations_->cthis()->setGetSharedGroupBlock(
+      [weakNativeReanimatedModule](int tag) -> std::vector<int> {
+        if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
+          return nativeReanimatedModule->layoutAnimationsManager()
+              .getSharedGroup(tag);
+        } else {
+          return {};
+        }
+      });
 }
 
 } // namespace reanimated

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

@@ -494,7 +494,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
   }
 
   public boolean hasAnimationForTag(int tag, int type) {
-    return mNativeMethodsHolder.hasAnimation(tag, type);
+    return mNativeMethodsHolder != null && mNativeMethodsHolder.hasAnimation(tag, type);
   }
 
   public boolean isLayoutAnimationEnabled() {
@@ -680,7 +680,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
   }
 
-  private View resolveView(int tag) {
+  protected View resolveView(int tag) {
     if (mExitingViews.containsKey(tag)) {
       return mExitingViews.get(tag);
     } else {
@@ -718,6 +718,14 @@ public class AnimationsManager implements ViewHierarchyObserver {
     mSharedTransitionManager.screenDidLayout(view);
   }
 
+  public void navigationTabChanged(View previousTab, View newTab) {
+    mSharedTransitionManager.navigationTabChanged(previousTab, newTab);
+  }
+
+  public void visitNativeTreeAndMakeSnapshot(View view) {
+    mSharedTransitionManager.visitNativeTreeAndMakeSnapshot(view);
+  }
+
   public void viewDidLayout(View view) {
     mSharedTransitionManager.viewDidLayout(view);
   }

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

@@ -52,6 +52,8 @@ public class LayoutAnimations {
 
   public native int findPrecedingViewTagForTransition(int tag);
 
+  public native int[] getSharedGroup(int tag);
+
   private void endLayoutAnimation(int tag, boolean removeView) {
     AnimationsManager animationsManager = getAnimationsManager();
     if (animationsManager == null) {

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

@@ -18,4 +18,6 @@ public interface NativeMethodsHolder {
   int findPrecedingViewTagForTransition(int tag);
 
   void checkDuplicateSharedTag(int viewTag, int screenTag);
+
+  int[] getSharedGroup(int viewTag);
 }

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

@@ -214,12 +214,14 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
   private final ReaLayoutAnimator mReaLayoutAnimator;
   private final HashMap<Integer, Set<Integer>> mPendingDeletionsForTag = new HashMap<>();
   private boolean initOk = true;
+  private final TabNavigatorObserver mTabNavigatorObserver;
 
   public ReanimatedNativeHierarchyManager(
       ViewManagerRegistry viewManagers, ReactApplicationContext reactContext) {
     super(viewManagers);
 
     mReaLayoutAnimator = new ReaLayoutAnimator(reactContext, this);
+    mTabNavigatorObserver = new TabNavigatorObserver(mReaLayoutAnimator);
 
     Class<?> clazz = this.getClass().getSuperclass();
     if (clazz == null) {
@@ -293,6 +295,14 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
         if (!hasHeader || !container.isLayoutRequested()) {
           mReaLayoutAnimator.getAnimationsManager().screenDidLayout(container);
         }
+        View screen = resolveView(tag);
+        View screenFragmentManager = (View) screen.getParent();
+        if (screenFragmentManager != null) {
+          View screenHolder = (View) screenFragmentManager.getParent();
+          if (ScreensHelper.isScreenContainer(screenHolder)) {
+            mTabNavigatorObserver.handleScreenContainerUpdate(screen);
+          }
+        }
       }
       View view = resolveView(tag);
       if (view != null && mReaLayoutAnimator != null) {

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

@@ -0,0 +1,83 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import android.util.Log;
+import android.view.View;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ScreensHelper {
+
+  public static View getTabNavigator(View view) {
+    View currentView = view;
+    while (currentView != null) {
+      if (isScreenContainer(currentView)) {
+        return currentView;
+      }
+      if (isScreen(currentView) && isScreensCoordinatorLayout(currentView.getParent())) {
+        View screen = currentView;
+        Class<?> screenClass = screen.getClass();
+        try {
+          Method getContainer = screenClass.getMethod("getContainer");
+          currentView = (View) getContainer.invoke(screen);
+        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+          String message =
+              e.getMessage() != null ? e.getMessage() : "Unable to invoke the getContainer method";
+          Log.e("[Reanimated]", message);
+          break;
+        }
+      } else if (currentView.getParent() instanceof View) {
+        currentView = (View) currentView.getParent();
+      } else {
+        break;
+      }
+    }
+    return null;
+  }
+
+  public static boolean isViewChildOfScreen(View view, View screen) {
+    View currentView = view;
+    while (currentView != null) {
+      if (currentView == screen) {
+        return true;
+      }
+      if (!(currentView.getParent() instanceof View)) {
+        return false;
+      }
+      currentView = (View) currentView.getParent();
+    }
+    return false;
+  }
+
+  public static View getTopScreenForStack(View view) {
+    if (isScreenStack(view)) {
+      View stack = view;
+      Class<?> screenStackClass = stack.getClass();
+      try {
+        Method getTopScreen = screenStackClass.getMethod("getTopScreen");
+        return (View) getTopScreen.invoke(stack);
+      } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException ignored) {
+      }
+    }
+    return view;
+  }
+
+  public static boolean isScreen(Object maybeView) {
+    return isInstanceOf(maybeView, "Screen");
+  }
+
+  public static boolean isScreenStack(Object maybeView) {
+    return isInstanceOf(maybeView, "ScreenStack");
+  }
+
+  public static boolean isScreenContainer(Object maybeView) {
+    return isInstanceOf(maybeView, "ScreenContainer");
+  }
+
+  public static boolean isScreensCoordinatorLayout(Object maybeView) {
+    return isInstanceOf(maybeView, "ScreensCoordinatorLayout");
+  }
+
+  private static boolean isInstanceOf(Object maybeView, String className) {
+    return maybeView != null && maybeView.getClass().getSimpleName().equals(className);
+  }
+}

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

@@ -193,6 +193,11 @@ public class SharedTransitionManager {
   }
 
   protected void onScreenWillDisappear() {
+    for (Integer tag : mTagsToCleanup) {
+      mNativeMethodsHolder.clearAnimationConfig(tag);
+    }
+    mTagsToCleanup.clear();
+
     if (!mIsTransitionPrepared) {
       return;
     }
@@ -205,11 +210,6 @@ public class SharedTransitionManager {
     }
 
     startPreparedTransitions();
-
-    for (Integer tag : mTagsToCleanup) {
-      mNativeMethodsHolder.clearAnimationConfig(tag);
-    }
-    mTagsToCleanup.clear();
   }
 
   private boolean tryStartSharedTransitionForViews(
@@ -265,17 +265,22 @@ public class SharedTransitionManager {
               mNativeMethodsHolder.findPrecedingViewTagForTransition(sharedView.getId());
         }
       }
+
       boolean bothAreRemoved = !addedNewScreen && viewTags.contains(targetViewTag);
       if (targetViewTag < 0) {
         continue;
       }
+
+      View siblingView = reanimatedNativeHierarchyManager.resolveView(targetViewTag);
+      siblingView = maybeOverrideSiblingForTabNavigator(sharedView, siblingView);
+
       View viewSource, viewTarget;
       if (addedNewScreen) {
-        viewSource = reanimatedNativeHierarchyManager.resolveView(targetViewTag);
+        viewSource = siblingView;
         viewTarget = sharedView;
       } else {
         viewSource = sharedView;
-        viewTarget = reanimatedNativeHierarchyManager.resolveView(targetViewTag);
+        viewTarget = siblingView;
       }
       if (bothAreRemoved) {
         // case for nested stack
@@ -293,33 +298,43 @@ public class SharedTransitionManager {
           continue;
         }
 
-        ViewGroup stack = (ViewGroup) findStack(viewSourceScreen);
-        if (stack == null) {
+        ViewGroup sourceStack = (ViewGroup) findStack(viewSourceScreen);
+        if (sourceStack == null) {
           continue;
         }
-
-        ViewGroupManager stackViewGroupManager =
-            (ViewGroupManager) reanimatedNativeHierarchyManager.resolveViewManager(stack.getId());
-        int screensCount = stackViewGroupManager.getChildCount(stack);
-
-        if (screensCount < 2) {
-          continue;
+        int stackId = sourceStack.getId();
+        ViewGroupManager stackViewManager =
+            (ViewGroupManager) reanimatedNativeHierarchyManager.resolveViewManager(stackId);
+        boolean isInSameStack = false;
+        for (int i = 0; i < stackViewManager.getChildCount(sourceStack); i++) {
+          if (stackViewManager.getChildAt(sourceStack, i) == viewTargetScreen) {
+            isInSameStack = true;
+          }
         }
+        if (isInSameStack) {
+          ViewGroupManager stackViewGroupManager =
+              (ViewGroupManager)
+                  reanimatedNativeHierarchyManager.resolveViewManager(sourceStack.getId());
+          int screensCount = stackViewGroupManager.getChildCount(sourceStack);
+          if (screensCount < 2) {
+            continue;
+          }
 
-        View topScreen = stackViewGroupManager.getChildAt(stack, screensCount - 1);
-        View secondScreen = stackViewGroupManager.getChildAt(stack, screensCount - 2);
-        boolean isValidConfiguration;
-        if (addedNewScreen) {
-          isValidConfiguration =
-              secondScreen.getId() == viewSourceScreen.getId()
-                  && topScreen.getId() == viewTargetScreen.getId();
-        } else {
-          isValidConfiguration =
-              topScreen.getId() == viewSourceScreen.getId()
-                  && secondScreen.getId() == viewTargetScreen.getId();
-        }
-        if (!isValidConfiguration) {
-          continue;
+          View topScreen = stackViewGroupManager.getChildAt(sourceStack, screensCount - 1);
+          View secondScreen = stackViewGroupManager.getChildAt(sourceStack, screensCount - 2);
+          boolean isValidConfiguration;
+          if (addedNewScreen) {
+            isValidConfiguration =
+                secondScreen.getId() == viewSourceScreen.getId()
+                    && topScreen.getId() == viewTargetScreen.getId();
+          } else {
+            isValidConfiguration =
+                topScreen.getId() == viewSourceScreen.getId()
+                    && secondScreen.getId() == viewTargetScreen.getId();
+          }
+          if (!isValidConfiguration) {
+            continue;
+          }
         }
       }
 
@@ -340,7 +355,7 @@ public class SharedTransitionManager {
       }
       Snapshot targetViewSnapshot = mSnapshotRegistry.get(viewTarget.getId());
       if (targetViewSnapshot == null) {
-        continue;
+        makeSnapshot(viewTarget);
       }
 
       newTransitionViews.add(viewSource);
@@ -379,6 +394,33 @@ public class SharedTransitionManager {
     return sharedElements;
   }
 
+  private View maybeOverrideSiblingForTabNavigator(View sharedView, View siblingView) {
+    View maybeTabNavigatorForSharedView = ScreensHelper.getTabNavigator(sharedView);
+
+    if (maybeTabNavigatorForSharedView == null) {
+      return siblingView;
+    }
+
+    int siblingTag = siblingView.getId();
+    int[] sharedGroup = mNativeMethodsHolder.getSharedGroup(sharedView.getId());
+    int siblingIndex = -1;
+    for (int i = 0; i < sharedGroup.length; i++) {
+      if (sharedGroup[i] == siblingTag) {
+        siblingIndex = i;
+      }
+    }
+
+    for (int i = siblingIndex; i >= 0; i--) {
+      int viewTag = sharedGroup[i];
+      View view = mAnimationsManager.resolveView(viewTag);
+      if (maybeTabNavigatorForSharedView == ScreensHelper.getTabNavigator(view)) {
+        return view;
+      }
+    }
+
+    return siblingView;
+  }
+
   private void setupTransitionContainer() {
     if (mTransitionContainer == null) {
       ReactContext context = mAnimationsManager.getContext();
@@ -640,6 +682,7 @@ public class SharedTransitionManager {
   }
 
   void visitNativeTreeAndMakeSnapshot(View view) {
+    view = ScreensHelper.getTopScreenForStack(view);
     if (!(view instanceof ViewGroup)) {
       return;
     }
@@ -696,4 +739,60 @@ public class SharedTransitionManager {
       }
     }
   }
+
+  public void navigationTabChanged(View previousTab, View newTab) {
+    mAddedSharedViews.clear();
+    List<SharedElement> sharedElements = new ArrayList<>();
+    List<View> sharedViews = new ArrayList<>();
+    findSharedViewsForScreen(previousTab, sharedViews);
+    sortViewsByTags(sharedViews);
+    for (View sharedView : sharedViews) {
+      int[] sharedGroup = mNativeMethodsHolder.getSharedGroup(sharedView.getId());
+      for (int i = sharedGroup.length - 1; i >= 0; i--) {
+        View targetView = mAnimationsManager.resolveView(sharedGroup[i]);
+        if (!ScreensHelper.isViewChildOfScreen(targetView, newTab)) {
+          continue;
+        }
+        Snapshot sourceViewSnapshot = mSnapshotRegistry.get(sharedView.getId());
+        if (sourceViewSnapshot == null) {
+          // This is just to ensure that we have a snapshot and to prevent
+          // a theoretically possible NullPointerException.
+          continue;
+        }
+        SharedElement sharedElement =
+            new SharedElement(sharedView, sourceViewSnapshot, targetView, new Snapshot(targetView));
+        sharedElements.add(sharedElement);
+        break;
+      }
+    }
+    if (sharedElements.isEmpty()) {
+      return;
+    }
+    mSharedElements = sharedElements;
+    mSharedElementsWithAnimation.clear();
+    for (SharedElement sharedElement : sharedElements) {
+      mSharedElementsLookup.put(sharedElement.sourceView.getId(), sharedElement);
+      mSharedElementsWithAnimation.add(sharedElement);
+    }
+    setupTransitionContainer();
+    reparentSharedViewsForCurrentTransition(sharedElements);
+    startSharedTransition(
+        mSharedElementsWithAnimation, LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION);
+  }
+
+  private void findSharedViewsForScreen(View view, List<View> sharedViews) {
+    view = ScreensHelper.getTopScreenForStack(view);
+    if (!(view instanceof ViewGroup)) {
+      return;
+    }
+    ViewGroup viewGroup = (ViewGroup) view;
+    if (mAnimationsManager.hasAnimationForTag(
+        view.getId(), LayoutAnimations.Types.SHARED_ELEMENT_TRANSITION)) {
+      sharedViews.add(view);
+    }
+    for (int i = 0; i < viewGroup.getChildCount(); i++) {
+      View child = viewGroup.getChildAt(i);
+      findSharedViewsForScreen(child, sharedViews);
+    }
+  }
 }

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

@@ -6,6 +6,8 @@ import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.NativeViewHierarchyManager;
 import com.facebook.react.uimanager.ViewManager;
 import com.swmansion.reanimated.ReactNativeUtils;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -117,9 +119,43 @@ public class Snapshot {
     borderRadii = new ReactNativeUtils.BorderRadii(0, 0, 0, 0, 0);
   }
 
+  private int[] tryGetRealPosition(View view) {
+    int[] location = new int[2];
+    View currentView = view;
+    while (currentView != null) {
+      location[0] += currentView.getX();
+      location[1] += currentView.getY();
+      if (ScreensHelper.isScreen(currentView)
+          && ScreensHelper.isScreensCoordinatorLayout(currentView.getParent())) {
+        View screen = currentView;
+        Class<?> screenClass = screen.getClass();
+        try {
+          Method getContainer = screenClass.getMethod("getContainer");
+          currentView = (View) getContainer.invoke(screen);
+        } catch (NoSuchMethodException
+            | InvocationTargetException
+            | IllegalAccessException ignored) {
+        }
+      } else if (currentView.getParent() instanceof View) {
+        currentView = (View) currentView.getParent();
+      } else {
+        break;
+      }
+    }
+    return location;
+  }
+
   public Snapshot(View view) {
     int[] location = new int[2];
     view.getLocationOnScreen(location);
+    if (location[0] == 0 && location[1] == 0) {
+      /*
+       In certain cases, when a view is correctly attached to the screen and has computed
+       the correct layout, but is not visible on the screen, `getLocationOnScreen` may return
+       incorrect values [0, 0]. This behavior can occur during tab changes in bottom tabs.
+      */
+      location = tryGetRealPosition(view);
+    }
     originX = location[0];
     originY = location[1];
     width = view.getWidth();

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

@@ -0,0 +1,128 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentManager;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TabNavigatorObserver {
+  private final Set<Integer> mFragmentsWithListenerRegistry = new HashSet<>();
+  private final ReaLayoutAnimator mReaLayoutAnimator;
+
+  public TabNavigatorObserver(ReaLayoutAnimator reaLayoutAnimator) {
+    mReaLayoutAnimator = reaLayoutAnimator;
+  }
+
+  public void handleScreenContainerUpdate(View screen) {
+    try {
+      Class<?> screenClass = screen.getClass();
+      Method getScreenFragment = screenClass.getMethod("getFragment");
+      Fragment fragment = (Fragment) getScreenFragment.invoke(screen);
+      int fragmentTag = fragment.getId();
+      if (!mFragmentsWithListenerRegistry.contains(fragmentTag)) {
+        mFragmentsWithListenerRegistry.add(fragmentTag);
+        fragment
+            .getParentFragmentManager()
+            .registerFragmentLifecycleCallbacks(new FragmentLifecycleCallbacks(fragment), true);
+      }
+    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+      String message = e.getMessage() != null ? e.getMessage() : "Unable to get screen fragment";
+      Log.e("[Reanimated]", message);
+    }
+  }
+
+  class FragmentLifecycleCallbacks extends FragmentManager.FragmentLifecycleCallbacks {
+    private View firstScreen;
+    private Method getScreen;
+    private Method getActivityState;
+    private final Set<Integer> screenTagsWithListener = new HashSet<>();
+    private final List<View> nextTransition = new ArrayList<>();
+
+    public FragmentLifecycleCallbacks(Fragment fragment) {
+      try {
+        Class<?> screenFragmentClass = fragment.getClass();
+        getScreen = screenFragmentClass.getMethod("getScreen");
+        View screen = (View) getScreen.invoke(fragment);
+        getActivityState = screen.getClass().getMethod("getActivityState");
+        addScreenListener(screen);
+      } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+        String message =
+            e.getMessage() != null ? e.getMessage() : "Unable to get screen activity state";
+        Log.e("[Reanimated]", message);
+      }
+    }
+
+    private void addScreenListener(View screen)
+        throws InvocationTargetException, IllegalAccessException {
+      if (screenTagsWithListener.contains(screen.getId())) {
+        return;
+      }
+      screenTagsWithListener.add(screen.getId());
+      screen.addOnAttachStateChangeListener(new OnAttachStateChangeListener());
+      screen.addOnLayoutChangeListener(
+          (v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) -> {
+            if (nextTransition.isEmpty()) {
+              return;
+            }
+            AnimationsManager animationsManager = mReaLayoutAnimator.getAnimationsManager();
+            animationsManager.navigationTabChanged(nextTransition.get(0), nextTransition.get(1));
+            nextTransition.clear();
+          });
+    }
+
+    public void onFragmentAttached(
+        FragmentManager fragmentManager, Fragment fragment, Context context) {
+      onFragmentUpdate(fragment, true);
+    }
+
+    public void onFragmentDetached(FragmentManager fragmentManager, Fragment fragment) {
+      onFragmentUpdate(fragment, false);
+    }
+
+    private void onFragmentUpdate(Fragment fragment, boolean isAttaching) {
+      try {
+        View screen = (View) getScreen.invoke(fragment);
+        if (getActivityState.invoke(screen) == null) {
+          return;
+        }
+        addScreenListener(screen);
+
+        if (firstScreen == null) {
+          firstScreen = screen;
+          return;
+        }
+
+        if (isAttaching) {
+          nextTransition.add(firstScreen);
+          nextTransition.add(screen);
+        } else {
+          nextTransition.add(screen);
+          nextTransition.add(firstScreen);
+        }
+        firstScreen = null;
+      } catch (IllegalAccessException | InvocationTargetException e) {
+        String message = e.getMessage() != null ? e.getMessage() : "Unable to get screen view";
+        Log.e("[Reanimated]", message);
+      }
+    }
+  }
+
+  class OnAttachStateChangeListener implements View.OnAttachStateChangeListener {
+    @Override
+    public void onViewAttachedToWindow(@NonNull View screen) {}
+
+    @Override
+    public void onViewDetachedFromWindow(@NonNull View screen) {
+      AnimationsManager animationsManager = mReaLayoutAnimator.getAnimationsManager();
+      animationsManager.visitNativeTreeAndMakeSnapshot(screen);
+    }
+  }
+}

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

@@ -135,6 +135,14 @@ public class NativeProxy extends NativeProxyCommon {
                     layoutAnimations.checkDuplicateSharedTag(viewTag, screenTag);
                 }
             }
+
+            public int[] getSharedGroup(int viewTag) {
+                LayoutAnimations layoutAnimations = weakLayoutAnimations.get();
+                if (layoutAnimations != null) {
+                    return layoutAnimations.getSharedGroup(viewTag);
+                }
+                return new int[]{};
+            }
         };
     }
 }