react-native-reanimated 3.8.0 → 3.9.0-layout-animation-experimental

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

@@ -44,13 +44,48 @@ NativeProxy::NativeProxy(
       rnRuntime_(rnRuntime),
       nativeReanimatedModule_(std::make_shared<NativeReanimatedModule>(
           *rnRuntime,
-          jsCallInvoker,
+          std::make_shared<JSScheduler>(*rnRuntime, jsCallInvoker),
           std::make_shared<JMessageQueueThread>(messageQueueThread),
           uiScheduler,
           getPlatformDependentMethods(),
-          valueUnpackerCode)),
+          valueUnpackerCode,
+          /* isBridgeless */ false)),
       layoutAnimations_(std::move(layoutAnimations)) {
 #ifdef RCT_NEW_ARCH_ENABLED
+  commonInit(fabricUIManager);
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+NativeProxy::NativeProxy(
+    jni::alias_ref<NativeProxy::javaobject> jThis,
+    jsi::Runtime *rnRuntime,
+    RuntimeExecutor runtimeExecutor,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    jni::global_ref<LayoutAnimations::javaobject> layoutAnimations,
+    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager,
+    const std::string &valueUnpackerCode)
+    : javaPart_(jni::make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      nativeReanimatedModule_(std::make_shared<NativeReanimatedModule>(
+          *rnRuntime,
+          std::make_shared<JSScheduler>(*rnRuntime, runtimeExecutor),
+          std::make_shared<JMessageQueueThread>(messageQueueThread),
+          uiScheduler,
+          getPlatformDependentMethods(),
+          valueUnpackerCode,
+          /* isBridgeless */ true)),
+      layoutAnimations_(std::move(layoutAnimations)) {
+  commonInit(fabricUIManager);
+}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+void NativeProxy::commonInit(
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        &fabricUIManager) {
   const auto &uiManager =
       fabricUIManager->getBinding()->getScheduler()->getUIManager();
   nativeReanimatedModule_->initializeFabric(uiManager);
@@ -63,8 +98,8 @@ NativeProxy::NativeProxy(
   //     });
   // reactScheduler_ = binding->getScheduler();
   // reactScheduler_->addEventListener(eventListener_);
-#endif
 }
+#endif // RCT_NEW_ARCH_ENABLED
 
 NativeProxy::~NativeProxy() {
   // removed temporary, new event listener mechanism need fix on the RN side
@@ -104,6 +139,31 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
       valueUnpackerCode);
 }
 
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybridBridgeless(
+    jni::alias_ref<jhybridobject> jThis,
+    jlong jsContext,
+    jni::alias_ref<react::JRuntimeExecutor::javaobject> runtimeExecutorHolder,
+    jni::alias_ref<AndroidUIScheduler::javaobject> androidUiScheduler,
+    jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations,
+    jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+    jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+        fabricUIManager,
+    const std::string &valueUnpackerCode) {
+  auto uiScheduler = androidUiScheduler->cthis()->getUIScheduler();
+  auto runtimeExecutor = runtimeExecutorHolder->cthis()->get();
+  return makeCxxInstance(
+      jThis,
+      (jsi::Runtime *)jsContext,
+      runtimeExecutor,
+      uiScheduler,
+      make_global(layoutAnimations),
+      messageQueueThread,
+      fabricUIManager,
+      valueUnpackerCode);
+}
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
 #ifndef NDEBUG
 void NativeProxy::checkJavaVersion(jsi::Runtime &rnRuntime) {
   std::string javaVersion;
@@ -177,13 +237,18 @@ bool NativeProxy::getIsReducedMotion() {
 }
 
 void NativeProxy::registerNatives() {
-  registerHybrid(
-      {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
-       makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
-       makeNativeMethod(
-           "isAnyHandlerWaitingForEvent",
-           NativeProxy::isAnyHandlerWaitingForEvent),
-       makeNativeMethod("performOperations", NativeProxy::performOperations)});
+  registerHybrid({
+    makeNativeMethod("initHybrid", NativeProxy::initHybrid),
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+        makeNativeMethod(
+            "initHybridBridgeless", NativeProxy::initHybridBridgeless),
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+        makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
+        makeNativeMethod(
+            "isAnyHandlerWaitingForEvent",
+            NativeProxy::isAnyHandlerWaitingForEvent),
+        makeNativeMethod("performOperations", NativeProxy::performOperations)
+  });
 }
 
 void NativeProxy::requestRender(
@@ -216,12 +281,12 @@ void NativeProxy::maybeFlushUIUpdatesQueue() {
 jsi::Value NativeProxy::obtainProp(
     jsi::Runtime &rt,
     const int viewTag,
-    const jsi::String &propName) {
+    const jsi::Value &propName) {
   static const auto method =
       getJniMethod<jni::local_ref<JString>(int, jni::local_ref<JString>)>(
           "obtainProp");
   local_ref<JString> propNameJStr =
-      jni::make_jstring(propName.utf8(rt).c_str());
+      jni::make_jstring(propName.asString(rt).utf8(rt).c_str());
   auto result = method(javaPart_.get(), viewTag, propNameJStr);
   std::string str = result->toStdString();
   return jsi::Value(rt, jsi::String::createFromAscii(rt, str));

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

@@ -3,6 +3,9 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #include <react/fabric/JFabricUIManager.h>
 #include <react/renderer/scheduler/Scheduler.h>
+#if REACT_NATIVE_MINOR_VERSION >= 74
+#include <react/jni/JRuntimeExecutor.h>
+#endif // REACT_NATIVE_MINOR_VERSION >= 74
 #endif
 
 #include <ReactCommon/CallInvokerHolder.h>
@@ -158,6 +161,19 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
           fabricUIManager,
 #endif
       const std::string &valueUnpackerCode);
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  static jni::local_ref<jhybriddata> initHybridBridgeless(
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      jni::alias_ref<react::JRuntimeExecutor::javaobject> runtimeExecutorHolder,
+      jni::alias_ref<AndroidUIScheduler::javaobject> androidUiScheduler,
+      jni::alias_ref<LayoutAnimations::javaobject> layoutAnimations,
+      jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager,
+      const std::string &valueUnpackerCode);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
   static void registerNatives();
 
   ~NativeProxy();
@@ -211,7 +227,7 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
   // nothing
 #else
   jsi::Value
-  obtainProp(jsi::Runtime &rt, const int viewTag, const jsi::String &propName);
+  obtainProp(jsi::Runtime &rt, const int viewTag, const jsi::Value &propName);
   void configureProps(
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
@@ -269,6 +285,24 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
           fabricUIManager,
 #endif
       const std::string &valueUnpackerCode);
+
+#if REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED)
+  explicit NativeProxy(
+      jni::alias_ref<NativeProxy::jhybridobject> jThis,
+      jsi::Runtime *rnRuntime,
+      RuntimeExecutor runtimeExecutor,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      jni::global_ref<LayoutAnimations::javaobject> layoutAnimations,
+      jni::alias_ref<JavaMessageQueueThread::javaobject> messageQueueThread,
+      jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+          fabricUIManager,
+      const std::string &valueUnpackerCode);
+#endif // REACT_NATIVE_MINOR_VERSION >= 74 && defined(RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  void commonInit(jni::alias_ref<facebook::react::JFabricUIManager::javaobject>
+                      &fabricUIManager);
+#endif // RCT_NEW_ARCH_ENABLED
 };
 
 } // namespace reanimated

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

@@ -2,6 +2,7 @@ package com.swmansion.reanimated;
 
 import static java.lang.Float.NaN;
 
+import android.graphics.drawable.Drawable;
 import android.view.View;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.GuardedRunnable;
@@ -11,6 +12,7 @@ import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
@@ -18,14 +20,18 @@ import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.uimanager.GuardedFrameCallback;
 import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.ReactShadowNode;
 import com.facebook.react.uimanager.ReactStylesDiffMap;
 import com.facebook.react.uimanager.UIImplementation;
+import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.UIManagerReanimatedHelper;
+import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.react.views.view.ReactViewBackgroundDrawable;
 import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
 import com.swmansion.reanimated.nativeProxy.NoopEventHandler;
 import java.util.ArrayList;
@@ -33,6 +39,7 @@ import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.ConcurrentLinkedQueue;
@@ -81,7 +88,7 @@ public class NodesManager implements EventDispatcherListener {
     void onAnimationFrame(double timestampMs);
   }
 
-  private AnimationsManager mAnimationManager;
+  private final AnimationsManager mAnimationManager;
   private final UIImplementation mUIImplementation;
   private final DeviceEventManagerModule.RCTDeviceEventEmitter mEventEmitter;
   private final ReactChoreographer mReactChoreographer;
@@ -89,7 +96,7 @@ public class NodesManager implements EventDispatcherListener {
   protected final UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
   private final AtomicBoolean mCallbackPosted = new AtomicBoolean();
   private final ReactContext mContext;
-  private final UIManagerModule mUIManager;
+  private final UIManager mUIManager;
   private ReactApplicationContext mReactApplicationContext;
   private RCTEventEmitter mCustomEventHandler = new NoopEventHandler();
   private List<OnAnimationFrame> mFrameCallbacks = new ArrayList<>();
@@ -144,9 +151,15 @@ public class NodesManager implements EventDispatcherListener {
 
   public NodesManager(ReactContext context) {
     mContext = context;
-    mUIManager = context.getNativeModule(UIManagerModule.class);
-    mUIImplementation = mUIManager.getUIImplementation();
-    mCustomEventNamesResolver = mUIManager.getDirectEventNamesResolver();
+    int uiManagerType =
+        BuildConfig.IS_NEW_ARCHITECTURE_ENABLED ? UIManagerType.FABRIC : UIManagerType.DEFAULT;
+    mUIManager = UIManagerHelper.getUIManager(context, uiManagerType);
+    assert mUIManager != null;
+    mUIImplementation =
+        mUIManager instanceof UIManagerModule
+            ? ((UIManagerModule) mUIManager).getUIImplementation()
+            : null;
+    mCustomEventNamesResolver = mUIManager::resolveCustomDirectEventName;
     mEventEmitter = context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
 
     mReactChoreographer = ReactChoreographer.getInstance();
@@ -159,14 +172,15 @@ public class NodesManager implements EventDispatcherListener {
         };
 
     // We register as event listener at the end, because we pass `this` and we haven't finished
-    // contructing an object yet.
+    // constructing an object yet.
     // This lead to a crash described in
     // https://github.com/software-mansion/react-native-reanimated/issues/604 which was caused by
     // Nodes Manager being constructed on UI thread and registering for events.
     // Events are handled in the native modules thread in the `onEventDispatch()` method.
     // This method indirectly uses `mChoreographerCallback` which was created after event
     // registration, creating race condition
-    mUIManager.getEventDispatcher().addListener(this);
+    Objects.requireNonNull(UIManagerHelper.getEventDispatcher(context, uiManagerType))
+        .addListener(this);
 
     mAnimationManager = new AnimationsManager(mContext, mUIManager);
   }
@@ -227,7 +241,8 @@ public class NodesManager implements EventDispatcherListener {
                 NativeUpdateOperation op = copiedOperationsQueue.remove();
                 ReactShadowNode shadowNode = mUIImplementation.resolveShadowNode(op.mViewTag);
                 if (shadowNode != null) {
-                  mUIManager.updateView(op.mViewTag, shadowNode.getViewClass(), op.mNativeProps);
+                  ((UIManagerModule) mUIManager)
+                      .updateView(op.mViewTag, shadowNode.getViewClass(), op.mNativeProps);
                 }
               }
               if (queueWasEmpty) {
@@ -242,7 +257,7 @@ public class NodesManager implements EventDispatcherListener {
         try {
           semaphore.tryAcquire(16, TimeUnit.MILLISECONDS);
         } catch (InterruptedException e) {
-          // if the thread is interruped we just continue and let the layout update happen
+          // if the thread is interrupted we just continue and let the layout update happen
           // asynchronously
         }
       }
@@ -390,17 +405,41 @@ public class NodesManager implements EventDispatcherListener {
   }
 
   public String obtainProp(int viewTag, String propName) {
-    View view = mUIManager.resolveView(viewTag);
-    String result =
-        "error: unknown propName " + propName + ", currently supported: opacity, zIndex";
-    if (propName.equals("opacity")) {
-      Float opacity = view.getAlpha();
-      result = Float.toString(opacity);
-    } else if (propName.equals("zIndex")) {
-      Float zIndex = view.getElevation();
-      result = Float.toString(zIndex);
+    View view;
+    try {
+      view = mUIManager.resolveView(viewTag);
+    } catch (Exception e) {
+      throw new IllegalStateException("[Reanimated] Unable to resolve view");
+    }
+
+    switch (propName) {
+      case "opacity":
+        return Float.toString(view.getAlpha());
+      case "zIndex":
+        return Float.toString(view.getElevation());
+      case "width":
+        return Float.toString(PixelUtil.toDIPFromPixel(view.getWidth()));
+      case "height":
+        return Float.toString(PixelUtil.toDIPFromPixel(view.getHeight()));
+      case "top":
+        return Float.toString(PixelUtil.toDIPFromPixel(view.getTop()));
+      case "left":
+        return Float.toString(PixelUtil.toDIPFromPixel(view.getLeft()));
+      case "backgroundColor":
+        Drawable background = view.getBackground();
+        if (!(background instanceof ReactViewBackgroundDrawable)) {
+          return "unable to resolve background color";
+        }
+        int actualColor = ((ReactViewBackgroundDrawable) background).getColor();
+        String invertedColor = String.format("%08x", (0xFFFFFFFF & actualColor));
+        // By default transparency is first, color second
+        return "#" + invertedColor.substring(2, 8) + invertedColor.substring(0, 2);
+      default:
+        throw new IllegalArgumentException(
+            "[Reanimated] Attempted to get unsupported property"
+                + propName
+                + " with function `getViewProp`");
     }
-    return result;
   }
 
   private static WritableMap copyReadableMap(ReadableMap map) {

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

@@ -11,9 +11,9 @@ 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.annotations.ReactModuleList;
 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.react.uimanager.ViewManager;
@@ -22,6 +22,11 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+@ReactModuleList(
+    nativeModules = {
+      ReanimatedModule.class,
+      ReanimatedUIManager.class,
+    })
 public class ReanimatedPackage extends TurboReactPackage implements ReactPackage {
 
   @Override
@@ -55,7 +60,7 @@ public class ReanimatedPackage extends TurboReactPackage implements ReactPackage
               reactModule.needsEagerInit(),
               reactModule.hasConstants(),
               reactModule.isCxxModule(),
-              TurboModule.class.isAssignableFrom(moduleClass)));
+              BuildConfig.IS_NEW_ARCHITECTURE_ENABLED));
     }
 
     return new ReactModuleInfoProvider() {

package/android/src/{reactNativeVersionPatch/ReanimatedUIManager/latest → main/java}/com/swmansion/reanimated/ReanimatedUIManagerFactory.java

@@ -2,7 +2,6 @@ package com.swmansion.reanimated;
 
 import android.os.Build;
 import android.util.Log;
-
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ReanimatedUIImplementation;
 import com.facebook.react.uimanager.ReanimatedUIManager;
@@ -10,14 +9,16 @@ import com.facebook.react.uimanager.UIImplementation;
 import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.uimanager.ViewManagerRegistry;
-
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.List;
 
 public class ReanimatedUIManagerFactory {
 
-  static UIManagerModule create(ReactApplicationContext reactContext, List<ViewManager> viewManagers, int minTimeLeftInFrameForNonBatchedOperationMs) {
+  static UIManagerModule create(
+      ReactApplicationContext reactContext,
+      List<ViewManager> viewManagers,
+      int minTimeLeftInFrameForNonBatchedOperationMs) {
     ViewManagerRegistry viewManagerRegistry = new ViewManagerRegistry(viewManagers);
 
     UIManagerModule uiManagerModule =
@@ -59,5 +60,4 @@ public class ReanimatedUIManagerFactory {
 
     return uiManagerModule;
   }
-
-}
+}

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

@@ -14,13 +14,13 @@ 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.UIManager;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.IViewManagerWithChildren;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.ReactStylesDiffMap;
 import com.facebook.react.uimanager.RootView;
-import com.facebook.react.uimanager.UIManagerModule;
 import com.facebook.react.uimanager.ViewManager;
 import com.swmansion.reanimated.AndroidUIScheduler;
 import com.swmansion.reanimated.Utils;
@@ -34,7 +34,7 @@ import javax.annotation.Nullable;
 public class AnimationsManager implements ViewHierarchyObserver {
   private WeakReference<AndroidUIScheduler> mWeakAndroidUIScheduler;
   private ReactContext mContext;
-  private UIManagerModule mUIManager;
+  private UIManager mUIManager;
   private NativeMethodsHolder mNativeMethodsHolder;
 
   private HashSet<Integer> mEnteringViews = new HashSet<>();
@@ -60,9 +60,9 @@ public class AnimationsManager implements ViewHierarchyObserver {
     mWeakAndroidUIScheduler = new WeakReference<>(androidUIScheduler);
   }
 
-  public AnimationsManager(ReactContext context, UIManagerModule uiManagerModule) {
+  public AnimationsManager(ReactContext context, UIManager uiManager) {
     mContext = context;
-    mUIManager = uiManagerModule;
+    mUIManager = uiManager;
     isInvalidated = false;
     mSharedTransitionManager = new SharedTransitionManager(this);
   }
@@ -714,8 +714,8 @@ public class AnimationsManager implements ViewHierarchyObserver {
     return new Point(fromPoint.x - toPoint[0], fromPoint.y - toPoint[1]);
   }
 
-  public void screenDidLayout() {
-    mSharedTransitionManager.screenDidLayout();
+  public void screenDidLayout(View view) {
+    mSharedTransitionManager.screenDidLayout(view);
   }
 
   public void viewDidLayout(View view) {
@@ -726,6 +726,10 @@ public class AnimationsManager implements ViewHierarchyObserver {
     mSharedTransitionManager.onViewsRemoval(tagsToDelete);
   }
 
+  public void notifyAboutScreenWillDisappear() {
+    mSharedTransitionManager.onScreenWillDisappear();
+  }
+
   public void makeSnapshotOfTopScreenViews(ViewGroup stack) {
     mSharedTransitionManager.doSnapshotForTopScreenViews(stack);
   }

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

@@ -6,13 +6,16 @@ import android.view.View;
 import android.view.ViewGroup;
 import androidx.annotation.Nullable;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.ViewAtIndex;
 import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.uimanager.ViewManagerRegistry;
+import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.layoutanimation.LayoutAnimationController;
 import com.facebook.react.uimanager.layoutanimation.LayoutAnimationListener;
 import com.swmansion.reanimated.ReanimatedModule;
@@ -164,6 +167,20 @@ class ReaLayoutAnimator extends LayoutAnimationController {
       if (parentName.equals("RNSScreenStack")) {
         mAnimationsManager.cancelAnimationsInSubviews(view);
         super.deleteView(view, listener);
+        EventDispatcher eventDispatcher =
+            UIManagerHelper.getEventDispatcherForReactTag(
+                (ReactContext) view.getContext(), view.getId());
+        if (eventDispatcher != null) {
+          eventDispatcher.addListener(
+              event -> {
+                // we schedule the start of transition for the ScreenWilDisappear event, so that the
+                // layout of the target screen is already calculated
+                // this allows us to make snapshots on the go, so that they are always up-to-date
+                if (event.getEventName().equals("topWillDisappear")) {
+                  getAnimationsManager().notifyAboutScreenWillDisappear();
+                }
+              });
+        }
         return;
       }
     }
@@ -264,7 +281,7 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
       if (container != null && viewManagerName.equals("RNSScreen") && mReaLayoutAnimator != null) {
         boolean hasHeader = checkIfTopScreenHasHeader((ViewGroup) container);
         if (!hasHeader || !container.isLayoutRequested()) {
-          mReaLayoutAnimator.getAnimationsManager().screenDidLayout();
+          mReaLayoutAnimator.getAnimationsManager().screenDidLayout(container);
         }
       }
       View view = resolveView(tag);