react-native-screens 3.32.0 → 3.34.0

package/common/cpp/react/renderer/components/rnscreens/RNSScreenComponentDescriptor.h

@@ -1,17 +1,27 @@
 #pragma once
 
+#ifdef ANDROID
+#include <fbjni/fbjni.h>
+#endif
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/components/rnscreens/Props.h>
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
 #include "RNSScreenShadowNode.h"
+#include "utils/RectUtil.h"
 
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 class RNSScreenComponentDescriptor final
     : public ConcreteComponentDescriptor<RNSScreenShadowNode> {
  public:
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
 
+  static constexpr const char *kScreenDummyLayoutHelperClass =
+      "com/swmansion/rnscreens/utils/ScreenDummyLayoutHelper";
+
   void adopt(ShadowNode &shadowNode) const override {
     react_native_assert(dynamic_cast<RNSScreenShadowNode *>(&shadowNode));
     auto &screenShadowNode = static_cast<RNSScreenShadowNode &>(shadowNode);
@@ -26,13 +36,142 @@ class RNSScreenComponentDescriptor final
             shadowNode.getState());
     auto stateData = state->getData();
 
+#ifdef ANDROID
     if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      // When we receive dimensions from JVM side we can remove padding used for
+      // correction, and we can stop applying height correction for the frame.
+      // We want to leave top offset correction though intact.
+      // TODO: In future, when we have dynamic header height we might want to
+      // update Y offset correction here.
+
+#ifdef REACT_NATIVE_DEBUG
+      // We use the fact that height correction is disabled once we receive
+      // state from the native, so when we have incoming state & height
+      // correction is still enabled, we know this is the very first native
+      // state update.
+      if (screenShadowNode.getFrameCorrectionModes().check(
+              FrameCorrectionModes::Mode::FrameHeightCorrection) &&
+          !checkFrameSizesEqualWithEps(
+              screenShadowNode.layoutMetrics_.frame.size,
+              stateData.frameSize)) {
+        LOG(ERROR)
+            << "[RNScreens] The first frame received from state update: "
+            << stateData.frameSize.width << "x" << stateData.frameSize.height
+            << " differs from the one expected: "
+            << screenShadowNode.layoutMetrics_.frame.size.width << "x"
+            << screenShadowNode.layoutMetrics_.frame.size.height
+            << ". This is most likely a react-native-screens library bug. Please report this at https://github.com/software-mansion/react-native-screens/issues";
+      }
+#endif
+
+      screenShadowNode.setPadding({0, 0, 0, 0});
+      screenShadowNode.getFrameCorrectionModes().unset(
+          FrameCorrectionModes::Mode::FrameHeightCorrection);
+
       layoutableShadowNode.setSize(
           Size{stateData.frameSize.width, stateData.frameSize.height});
-    }
+    } else {
+      // This code path should be executed only on the very first (few)
+      // layout(s), when we haven't received state update from JVM side yet.
+
+      auto headerConfigChildOpt = findHeaderConfigChild(layoutableShadowNode);
+
+      // During creation of the shadow node children are not attached yet.
+      // We also do not want to set any padding in case.
+      if (headerConfigChildOpt) {
+        const auto &headerConfigChild = headerConfigChildOpt->get();
+        const auto &headerProps =
+            *std::static_pointer_cast<const RNSScreenStackHeaderConfigProps>(
+                headerConfigChild->getProps());
+
+        const auto headerHeight = headerProps.hidden
+            ? 0.f
+            : findHeaderHeight(
+                  headerProps.titleFontSize, headerProps.title.empty())
+                  .value_or(0.f);
 
+        screenShadowNode.setPadding({0, 0, 0, headerHeight});
+        screenShadowNode.setHeaderHeight(headerHeight);
+        screenShadowNode.getFrameCorrectionModes().set(
+            FrameCorrectionModes::Mode(
+                FrameCorrectionModes::Mode::FrameHeightCorrection |
+                FrameCorrectionModes::Mode::FrameOriginCorrection));
+      }
+    }
+#else
+    if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      layoutableShadowNode.setSize(
+          Size{stateData.frameSize.width, stateData.frameSize.height});
+    }
+#endif // ANDROID
     ConcreteComponentDescriptor::adopt(shadowNode);
   }
+
+  std::optional<std::reference_wrapper<const ShadowNode::Shared>>
+  findHeaderConfigChild(
+      const YogaLayoutableShadowNode &screenShadowNode) const {
+    for (const ShadowNode::Shared &child : screenShadowNode.getChildren()) {
+      if (std::strcmp(
+              child->getComponentName(), "RNSScreenStackHeaderConfig") == 0) {
+        return {std::cref(child)};
+      }
+    }
+    return {};
+  }
+
+#ifdef ANDROID
+  std::optional<float> findHeaderHeight(
+      const int fontSize,
+      const bool isTitleEmpty) const {
+    JNIEnv *env = facebook::jni::Environment::current();
+
+    if (env == nullptr) {
+      LOG(ERROR) << "[RNScreens] Failed to retrieve env\n";
+      return {};
+    }
+
+    jclass layoutHelperClass = env->FindClass(kScreenDummyLayoutHelperClass);
+
+    if (layoutHelperClass == nullptr) {
+      LOG(ERROR) << "[RNScreens] Failed to find class with id "
+                 << kScreenDummyLayoutHelperClass;
+      return {};
+    }
+
+    jmethodID computeDummyLayoutID =
+        env->GetMethodID(layoutHelperClass, "computeDummyLayout", "(IZ)F");
+
+    if (computeDummyLayoutID == nullptr) {
+      LOG(ERROR)
+          << "[RNScreens] Failed to retrieve computeDummyLayout method ID";
+      return {};
+    }
+
+    jmethodID getInstanceMethodID = env->GetStaticMethodID(
+        layoutHelperClass,
+        "getInstance",
+        "()Lcom/swmansion/rnscreens/utils/ScreenDummyLayoutHelper;");
+
+    if (getInstanceMethodID == nullptr) {
+      LOG(ERROR) << "[RNScreens] Failed to retrieve getInstanceMethodID";
+      return {};
+    }
+
+    jobject packageInstance =
+        env->CallStaticObjectMethod(layoutHelperClass, getInstanceMethodID);
+
+    if (packageInstance == nullptr) {
+      LOG(ERROR)
+          << "[RNScreens] Failed to retrieve packageInstance or the package instance was null on JVM side";
+      return {};
+    }
+
+    jfloat headerHeight = env->CallFloatMethod(
+        packageInstance, computeDummyLayoutID, fontSize, isTitleEmpty);
+
+    return {headerHeight};
+  }
+#endif // ANDROID
 };
 
 } // namespace react

package/common/cpp/react/renderer/components/rnscreens/RNSScreenShadowNode.cpp

@@ -3,13 +3,63 @@
 namespace facebook {
 namespace react {
 
+namespace yoga = facebook::yoga;
+using namespace rnscreens;
+
 extern const char RNSScreenComponentName[] = "RNSScreen";
 
-Point RNSScreenShadowNode::getContentOriginOffset() const {
+Point RNSScreenShadowNode::getContentOriginOffset(
+    bool /*includeTransform*/) const {
   auto stateData = getStateData();
   auto contentOffset = stateData.contentOffset;
   return {contentOffset.x, contentOffset.y};
 }
 
+void RNSScreenShadowNode::layout(facebook::react::LayoutContext layoutContext) {
+  YogaLayoutableShadowNode::layout(layoutContext);
+
+#ifdef ANDROID
+  applyFrameCorrections();
+#endif // ANDROID
+}
+
+#ifdef ANDROID
+void RNSScreenShadowNode::applyFrameCorrections() {
+  ensureUnsealed();
+
+  // On the very first layout we want to correct both Y offset and frame size.
+  // On consecutive layouts we want to correct only Y offset, as the frame size
+  // is received from JVM side. This is done so if the Screen dimensions are
+  // read from ShadowTree (e.g by reanimated) they have chance of being
+  // accurate. On JVM side we do ignore this frame anyway, because
+  // ScreenStackViewManager.needsCustomLayoutForChildren() == true.
+  const auto &stateData = getStateData();
+  const float lastKnownHeaderHeight = stateData.getLastKnownHeaderHeight();
+  const auto &headerCorrectionModes = stateData.getHeaderCorrectionModes();
+  layoutMetrics_.frame.origin.y += lastKnownHeaderHeight *
+      headerCorrectionModes.check(
+          FrameCorrectionModes::Mode::FrameOriginCorrection);
+  layoutMetrics_.frame.size.height -= lastKnownHeaderHeight *
+      headerCorrectionModes.check(
+          FrameCorrectionModes::Mode::FrameHeightCorrection);
+}
+
+void RNSScreenShadowNode::setHeaderHeight(float headerHeight) {
+  getStateDataMutable().setHeaderHeight(headerHeight);
+}
+
+FrameCorrectionModes &RNSScreenShadowNode::getFrameCorrectionModes() {
+  return getStateDataMutable().getFrameCorrectionModes();
+}
+
+RNSScreenShadowNode::StateData &RNSScreenShadowNode::getStateDataMutable() {
+  // We assume that this method is called to mutate the data, so we ensure
+  // we're unsealed.
+  ensureUnsealed();
+  return const_cast<RNSScreenShadowNode::StateData &>(getStateData());
+}
+
+#endif // ANDROID
+
 } // namespace react
 } // namespace facebook

package/common/cpp/react/renderer/components/rnscreens/RNSScreenShadowNode.h

@@ -4,11 +4,15 @@
 #include <react/renderer/components/rnscreens/EventEmitters.h>
 #include <react/renderer/components/rnscreens/Props.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutContext.h>
+#include "FrameCorrectionModes.h"
 #include "RNSScreenState.h"
 
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 JSI_EXPORT extern const char RNSScreenComponentName[];
 
 class JSI_EXPORT RNSScreenShadowNode final : public ConcreteViewShadowNode<
@@ -18,8 +22,26 @@ class JSI_EXPORT RNSScreenShadowNode final : public ConcreteViewShadowNode<
                                                  RNSScreenState> {
  public:
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+
+#pragma mark - ShadowNode overrides
+
+  Point getContentOriginOffset(bool includeTransform) const override;
+
+  void layout(LayoutContext layoutContext) override;
+
+#pragma mark - Custom interface
+
+  void setHeaderHeight(float headerHeight);
+
+  FrameCorrectionModes &getFrameCorrectionModes();
+
+ private:
+#ifdef ANDROID
+  void applyFrameCorrections();
 
-  Point getContentOriginOffset() const override;
+  StateData &getStateDataMutable();
+#endif // ANDROID
 };
 
 } // namespace react

package/common/cpp/react/renderer/components/rnscreens/RNSScreenState.cpp

@@ -3,12 +3,32 @@
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 #ifdef ANDROID
 folly::dynamic RNSScreenState::getDynamic() const {
   return folly::dynamic::object("frameWidth", frameSize.width)(
       "frameHeight", frameSize.height)("contentOffsetX", contentOffset.x)(
       "contentOffsetY", contentOffset.y);
 }
+
+void RNSScreenState::setHeaderHeight(float headerHeight) {
+  lastKnownHeaderHeight_ = headerHeight;
+}
+
+float RNSScreenState::getLastKnownHeaderHeight() const noexcept {
+  return lastKnownHeaderHeight_;
+}
+
+FrameCorrectionModes &RNSScreenState::getFrameCorrectionModes() noexcept {
+  return headerCorrectionModes_;
+}
+
+const FrameCorrectionModes &RNSScreenState::getHeaderCorrectionModes()
+    const noexcept {
+  return headerCorrectionModes_;
+}
+
 #endif
 
 } // namespace react

package/common/cpp/react/renderer/components/rnscreens/RNSScreenState.h

@@ -9,9 +9,13 @@
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
 #endif
 
+#include "FrameCorrectionModes.h"
+
 namespace facebook {
 namespace react {
 
+using namespace rnscreens;
+
 class JSI_EXPORT RNSScreenState final {
  public:
   using Shared = std::shared_ptr<const RNSScreenState>;
@@ -27,7 +31,9 @@ class JSI_EXPORT RNSScreenState final {
             (Float)data["frameHeight"].getDouble()}),
         contentOffset(Point{
             (Float)data["contentOffsetX"].getDouble(),
-            (Float)data["contentOffsetY"].getDouble()}){};
+            (Float)data["contentOffsetY"].getDouble()}),
+        lastKnownHeaderHeight_{previousState.lastKnownHeaderHeight_},
+        headerCorrectionModes_{previousState.headerCorrectionModes_} {};
 #endif
 
   const Size frameSize{};
@@ -39,8 +45,24 @@ class JSI_EXPORT RNSScreenState final {
     return MapBufferBuilder::EMPTY();
   };
 
+  void setHeaderHeight(float headerHeight);
+
+  float getLastKnownHeaderHeight() const noexcept;
+
+  FrameCorrectionModes &getFrameCorrectionModes() noexcept;
+
+  const FrameCorrectionModes &getHeaderCorrectionModes() const noexcept;
+
 #endif
 
+ private:
+#ifdef ANDROID
+  // Header height as measured on dummy layout
+  float lastKnownHeaderHeight_{0.f};
+
+  FrameCorrectionModes headerCorrectionModes_{};
+#endif // ANDROID
+
 #pragma mark - Getters
 };
 

package/common/cpp/react/renderer/components/rnscreens/utils/RectUtil.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Size.h>
+#include <cmath>
+#include <concepts>
+
+namespace rnscreens {
+
+namespace react = facebook::react;
+
+template <typename T>
+  requires std::is_floating_point_v<T>
+inline constexpr bool equalWithRespectToEps(const T a, const T b, const T eps) {
+  return std::abs(a - b) <= eps;
+}
+
+/**
+ * Compares given two frame sizes with respect to the epsilon.
+ *
+ * @param first first frame size
+ * @param second second frame size
+ * @param eps comparison precision, defaults to 0.01, which should ensure that
+ * precision of comparison is under 1px
+ * @return whether the frame dimensions are the same with respect to given
+ * epsilon
+ */
+inline constexpr bool checkFrameSizesEqualWithEps(
+    const react::Size &first,
+    const react::Size &second,
+    const react::Float eps = 0.01) {
+  return equalWithRespectToEps(first.width, second.width, eps) &&
+      equalWithRespectToEps(first.height, second.height, eps);
+}
+
+} // namespace rnscreens

package/cpp/RNSScreenRemovalListener.cpp

@@ -0,0 +1,25 @@
+#include "RNSScreenRemovalListener.h"
+#include <react/renderer/mounting/ShadowViewMutation.h>
+using namespace facebook::react;
+
+std::optional<MountingTransaction> RNSScreenRemovalListener::pullTransaction(
+    SurfaceId surfaceId,
+    MountingTransaction::Number transactionNumber,
+    const TransactionTelemetry &telemetry,
+    ShadowViewMutationList mutations) const {
+  for (const ShadowViewMutation &mutation : mutations) {
+    if (mutation.type == ShadowViewMutation::Type::Remove &&
+        mutation.oldChildShadowView.componentName != nullptr &&
+        strcmp(mutation.parentShadowView.componentName, "RNSScreenStack") ==
+            0) {
+      listenerFunction_(mutation.oldChildShadowView.tag);
+    }
+  }
+
+  return MountingTransaction{
+      surfaceId, transactionNumber, std::move(mutations), telemetry};
+}
+
+bool RNSScreenRemovalListener::shouldOverridePullTransaction() const {
+  return true;
+}

package/cpp/RNSScreenRemovalListener.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+using namespace facebook::react;
+
+struct RNSScreenRemovalListener : public MountingOverrideDelegate {
+  std::function<void(int)> listenerFunction_;
+  RNSScreenRemovalListener(std::function<void(int)> &&listenerFunction_)
+      : listenerFunction_(std::move(listenerFunction_)) {}
+
+  bool shouldOverridePullTransaction() const override;
+  std::optional<MountingTransaction> pullTransaction(
+      SurfaceId surfaceId,
+      MountingTransaction::Number number,
+      const TransactionTelemetry &telemetry,
+      ShadowViewMutationList mutations) const override;
+};

package/ios/RNSConvert.h

@@ -1,4 +1,5 @@
 #ifdef RCT_NEW_ARCH_ENABLED
+#import <UIKit/UIKit.h>
 #import <react/renderer/components/rnscreens/Props.h>
 #import "RNSEnums.h"
 

package/ios/RNSModalScreen.mm

@@ -7,6 +7,28 @@
 
 @implementation RNSModalScreen
 
+// When using UIModalPresentationStyleFullScreen the whole view hierarchy mounted under primary `UITransitionView` is
+// removed, including React's root view, which observes for trait collection changes & sends it to `Appearance` module
+// via system notification centre. To workaround this detached-root-view-situation we emit the event to React's
+// `Appearance` module ourselves. For the RCTRootView observer, visit
+// https://github.com/facebook/react-native/blob/d3e0430deac573fd44792e6005d5de20e9ad2797/packages/react-native/React/Base/RCTRootView.m#L362
+// For more information, see https://github.com/software-mansion/react-native-screens/pull/2211.
+- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection
+{
+  [super traitCollectionDidChange:previousTraitCollection];
+  if (RCTSharedApplication().applicationState == UIApplicationStateBackground ||
+      self.stackPresentation != RNSScreenStackPresentationFullScreenModal) {
+    return;
+  }
+
+  [[NSNotificationCenter defaultCenter]
+      postNotificationName:RCTUserInterfaceStyleDidChangeNotification
+                    object:self
+                  userInfo:@{
+                    RCTUserInterfaceStyleDidChangeNotificationTraitCollectionKey : self.traitCollection,
+                  }];
+}
+
 #ifdef RCT_NEW_ARCH_ENABLED
 + (react::ComponentDescriptorProvider)componentDescriptorProvider
 {

package/ios/RNSModule.mm

@@ -116,7 +116,7 @@ RCT_EXPORT_MODULE()
 {
   RNSScreenStackView *view = [self getScreenStackView:stackTag];
   if (view != nil && ![view isKindOfClass:[RNSScreenStackView class]]) {
-    RCTLogError(@"Invalid view type, expecting RNSScreenStackView, got: %@", view);
+    RCTLogError(@"[RNScreens] Invalid view type, expecting RNSScreenStackView, got: %@", view);
     return nil;
   }
   return view;

package/ios/RNSScreen.h

@@ -40,7 +40,7 @@ namespace react = facebook::react;
 - (void)notifyFinishTransitioning;
 - (RNSScreenView *)screenView;
 #ifdef RCT_NEW_ARCH_ENABLED
-- (void)setViewToSnapshot:(UIView *)snapshot;
+- (void)setViewToSnapshot;
 - (CGFloat)calculateHeaderHeightIsModal:(BOOL)isModal;
 #endif
 
@@ -56,6 +56,7 @@ namespace react = facebook::react;
 #endif
 
 @property (nonatomic) BOOL fullScreenSwipeEnabled;
+@property (nonatomic) BOOL fullScreenSwipeShadowEnabled;
 @property (nonatomic) BOOL gestureEnabled;
 @property (nonatomic) BOOL hasStatusBarHiddenSet;
 @property (nonatomic) BOOL hasStatusBarStyleSet;

package/ios/RNSScreen.mm

@@ -25,6 +25,8 @@
 #import "RNSScreenStack.h"
 #import "RNSScreenStackHeaderConfig.h"
 
+#import "UIView+RNSUtility.h"
+
 #ifdef RCT_NEW_ARCH_ENABLED
 namespace react = facebook::react;
 #endif // RCT_NEW_ARCH_ENABLED
@@ -414,7 +416,7 @@ namespace react = facebook::react;
       [[RNSHeaderHeightChangeEvent alloc] initWithEventName:@"onHeaderHeightChange"
                                                    reactTag:[NSNumber numberWithInt:self.tag]
                                                headerHeight:headerHeight];
-  [[RCTBridge currentBridge].eventDispatcher notifyObserversOfEvent:event];
+  [self postNotificationForEventDispatcherObserversWithEvent:event];
 #else
   if (self.onHeaderHeightChange) {
     self.onHeaderHeightChange(@{
@@ -473,22 +475,13 @@ namespace react = facebook::react;
   }
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (RCTSurfaceTouchHandler *)touchHandler
-#else
-- (RCTTouchHandler *)touchHandler
-#endif
+- (nullable RNS_TOUCH_HANDLER_ARCH_TYPE *)touchHandler
 {
   if (_touchHandler != nil) {
     return _touchHandler;
   }
-  UIView *parent = [self superview];
-  while (parent != nil && ![parent respondsToSelector:@selector(touchHandler)])
-    parent = parent.superview;
-  if (parent != nil) {
-    return [parent performSelector:@selector(touchHandler)];
-  }
-  return nil;
+
+  return [self rnscreens_findTouchHandlerInAncestorChain];
 }
 
 - (void)notifyFinishTransitioning
@@ -509,7 +502,7 @@ namespace react = facebook::react;
                                                                    progress:progress
                                                                     closing:closing
                                                                goingForward:goingForward];
-  [[RCTBridge currentBridge].eventDispatcher notifyObserversOfEvent:event];
+  [self postNotificationForEventDispatcherObserversWithEvent:event];
 #else
   if (self.onTransitionProgress) {
     self.onTransitionProgress(@{
@@ -667,6 +660,14 @@ namespace react = facebook::react;
 #pragma mark - Fabric specific
 #ifdef RCT_NEW_ARCH_ENABLED
 
+- (void)postNotificationForEventDispatcherObserversWithEvent:(NSObject<RCTEvent> *)event
+{
+  NSDictionary *userInfo = [NSDictionary dictionaryWithObjectsAndKeys:event, @"event", nil];
+  [[NSNotificationCenter defaultCenter] postNotificationName:@"RCTNotifyEventDispatcherObserversOfEvent_DEPRECATED"
+                                                      object:nil
+                                                    userInfo:userInfo];
+}
+
 - (BOOL)hasHeaderConfig
 {
   return _config != nil;
@@ -710,6 +711,8 @@ namespace react = facebook::react;
 
   [self setFullScreenSwipeEnabled:newScreenProps.fullScreenSwipeEnabled];
 
+  [self setFullScreenSwipeShadowEnabled:newScreenProps.fullScreenSwipeShadowEnabled];
+
   [self setGestureEnabled:newScreenProps.gestureEnabled];
 
   [self setTransitionDuration:[NSNumber numberWithInt:newScreenProps.transitionDuration]];
@@ -793,7 +796,7 @@ namespace react = facebook::react;
   _newLayoutMetrics = layoutMetrics;
   _oldLayoutMetrics = oldLayoutMetrics;
   UIViewController *parentVC = self.reactViewController.parentViewController;
-  if (parentVC != nil && ![parentVC isKindOfClass:[RNSNavigationController class]]) {
+  if (parentVC == nil || ![parentVC isKindOfClass:[RNSNavigationController class]]) {
     [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
   }
   // when screen is mounted under RNSNavigationController it's size is controller
@@ -1388,12 +1391,16 @@ Class<RCTComponentViewProtocol> RNSScreenCls(void)
 #ifdef RCT_NEW_ARCH_ENABLED
 #pragma mark - Fabric specific
 
-- (void)setViewToSnapshot:(UIView *)snapshot
+- (void)setViewToSnapshot
 {
   UIView *superView = self.view.superview;
-  [self.view removeFromSuperview];
-  self.view = snapshot;
-  [superView addSubview:self.view];
+  // if we dismissed the view natively, it will already be detached from view hierarchy
+  if (self.view.window != nil) {
+    UIView *snapshot = [self.view snapshotViewAfterScreenUpdates:NO];
+    [self.view removeFromSuperview];
+    self.view = snapshot;
+    [superView addSubview:snapshot];
+  }
 }
 
 #else
@@ -1434,6 +1441,7 @@ RCT_EXPORT_MODULE()
 RCT_REMAP_VIEW_PROPERTY(activityState, activityStateOrNil, NSNumber)
 RCT_EXPORT_VIEW_PROPERTY(customAnimationOnSwipe, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(fullScreenSwipeEnabled, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(fullScreenSwipeShadowEnabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(gestureEnabled, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(gestureResponseDistance, NSDictionary)
 RCT_EXPORT_VIEW_PROPERTY(hideKeyboardOnSwipe, BOOL)