react-native-screens 3.11.0 → 3.13.0

package/android/src/paper/java/com/swmansion/rnscreens/FabricEnabledViewGroup.kt

@@ -0,0 +1,16 @@
+package com.swmansion.rnscreens
+
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactContext
+import androidx.annotation.UiThread
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import kotlin.math.abs
+
+abstract class FabricEnabledViewGroup constructor(context: ReactContext?) : ViewGroup(context) {
+  protected fun updateScreenSizeFabric(width: Int, height: Int) {
+    // do nothing
+  }
+}

package/common/cpp/Android.mk

@@ -0,0 +1,38 @@
+SCREENS_COMMON_THIS_DIR := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_PATH := $(SCREENS_COMMON_THIS_DIR)
+LOCAL_MODULE := rnscreens_common
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH) $(GENERATED_SRC_DIR)/codegen/jni
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/**/*.cpp) 
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH) $(GENERATED_SRC_DIR)/codegen/jni
+
+# Please note as one of the library listed is libreact_codegen_samplelibrary
+# This name will be generated as libreact_codegen_<library-name>
+# where <library-name> is the one you specified in the Gradle configuration
+LOCAL_SHARED_LIBRARIES := libjsi \
+    libfbjni \
+    libglog \
+    libfolly_json \
+    libyoga \
+    libreact_nativemodule_core \
+    libturbomodulejsijni \
+    librrc_view \
+    libreact_render_core \
+    libreact_render_graphics \
+    libfabricjni \
+    libfolly_futures \
+    libreact_debug \
+    libreact_render_componentregistry \
+    libreact_render_debug \
+    libruntimeexecutor \
+    libreact_codegen_rncore \
+    libreact_codegen_rnscreens
+
+LOCAL_CFLAGS := \
+    -DLOG_TAG=\"ReactNative\"
+LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
+
+include $(BUILD_SHARED_LIBRARY)

package/common/cpp/rnscreens/RNSScreenComponentDescriptor.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <react/debug/react_native_assert.h>
+#include "RNSScreenShadowNode.h"
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+class RNSScreenComponentDescriptor final
+    : public ConcreteComponentDescriptor<RNSScreenShadowNode> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode::Unshared const &shadowNode) const override {
+    react_native_assert(
+        std::dynamic_pointer_cast<RNSScreenShadowNode>(shadowNode));
+    auto screenShadowNode =
+        std::static_pointer_cast<RNSScreenShadowNode>(shadowNode);
+
+    react_native_assert(
+        std::dynamic_pointer_cast<YogaLayoutableShadowNode>(screenShadowNode));
+    auto layoutableShadowNode =
+        std::static_pointer_cast<YogaLayoutableShadowNode>(screenShadowNode);
+
+    auto state =
+        std::static_pointer_cast<const RNSScreenShadowNode::ConcreteState>(
+            shadowNode->getState());
+    auto stateData = state->getData();
+
+    if (stateData.frameSize.width != 0 && stateData.frameSize.height != 0) {
+      layoutableShadowNode->setSize(
+          Size{stateData.frameSize.width, stateData.frameSize.height});
+    }
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace react
+} // namespace facebook

package/common/cpp/rnscreens/RNSScreenShadowNode.cpp

@@ -0,0 +1,9 @@
+#include "RNSScreenShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+extern const char RNSScreenComponentName[] = "RNSScreen";
+
+} // namespace react
+} // namespace facebook

package/common/cpp/rnscreens/RNSScreenShadowNode.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RNSScreenState.h"
+#include <react/renderer/components/rnscreens/EventEmitters.h>
+#include <react/renderer/components/rnscreens/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook {
+namespace react {
+
+extern const char RNSScreenComponentName[];
+
+class RNSScreenShadowNode final : public ConcreteViewShadowNode<
+                                          RNSScreenComponentName,
+                                          RNSScreenProps,
+                                          RNSScreenEventEmitter,
+                                          RNSScreenState> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  static ShadowNodeTraits BaseTraits() {
+    auto traits = ConcreteViewShadowNode::BaseTraits();
+    traits.set(ShadowNodeTraits::Trait::RootNodeKind);
+    return traits;
+  }
+};
+
+} // namespace react
+} // namespace facebook

package/common/cpp/rnscreens/RNSScreenState.cpp

@@ -0,0 +1,14 @@
+#include "RNSScreenState.h"
+
+namespace facebook {
+namespace react {
+
+#ifdef ANDROID
+folly::dynamic RNSScreenState::getDynamic() const {
+  return folly::dynamic::object("frameWidth", frameSize.width)(
+      "frameHeight", frameSize.height);
+}
+#endif
+
+} // namespace react
+} // namespace facebook

package/common/cpp/rnscreens/RNSScreenState.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Geometry.h>
+#include <react/renderer/graphics/conversions.h>
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook {
+namespace react {
+
+class RNSScreenState final {
+ public:
+  using Shared = std::shared_ptr<const RNSScreenState>;
+
+  RNSScreenState(){};
+  RNSScreenState(Size frameSize_) : frameSize(frameSize_){};
+
+#ifdef ANDROID
+  RNSScreenState(
+      RNSScreenState const &previousState,
+      folly::dynamic data)
+      : frameSize(Size{
+            (Float)data["frameWidth"].getDouble(),
+            (Float)data["frameHeight"].getDouble()}){};
+#endif
+
+  const Size frameSize{};
+
+#ifdef ANDROID
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  };
+
+#endif
+
+#pragma mark - Getters
+};
+
+} // namespace react
+} // namespace facebook

package/ios/RNSScreen.h

@@ -30,8 +30,8 @@ typedef NS_ENUM(NSInteger, RNSScreenReplaceAnimation) {
 };
 
 typedef NS_ENUM(NSInteger, RNSScreenSwipeDirection) {
-  RNSScreenSwipeDirectionVertical,
   RNSScreenSwipeDirectionHorizontal,
+  RNSScreenSwipeDirectionVertical,
 };
 
 typedef NS_ENUM(NSInteger, RNSActivityState) {

package/ios/RNSScreenComponentView.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+
+#import <React/RCTViewComponentView.h>
+#import "RNSScreenController.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSScreenComponentView : RCTViewComponentView
+
+@property (weak, nonatomic) UIView *reactSuperview;
+@property (weak, nonatomic) UIView *config;
+@property (nonatomic, retain) RNSScreenController *controller;
+
+- (void)notifyWillAppear;
+- (void)notifyWillDisappear;
+- (void)notifyAppear;
+- (void)notifyDisappear;
+- (void)updateBounds;
+- (void)notifyDismissedWithCount:(int)dismissCount;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNSScreenComponentView.mm

@@ -0,0 +1,159 @@
+#import "RNSScreenComponentView.h"
+#import "RNSScreenStackHeaderConfigComponentView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTMountingTransactionObserving.h>
+
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#import <rnscreens/RNSScreenComponentDescriptor.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RNSScreenComponentView () <RCTRNSScreenViewProtocol, RCTMountingTransactionObserving>
+@end
+
+@implementation RNSScreenComponentView {
+  RNSScreenController *_controller;
+  RNSScreenShadowNode::ConcreteState::Shared _state;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNSScreenProps>();
+    _props = defaultProps;
+    _controller = [[RNSScreenController alloc] initWithView:self];
+  }
+
+  return self;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [super mountChildComponentView:childComponentView index:index];
+  if ([childComponentView isKindOfClass:[RNSScreenStackHeaderConfigComponentView class]]) {
+    _config = childComponentView;
+    ((RNSScreenStackHeaderConfigComponentView *)childComponentView).screenView = self;
+  }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [self.controller setViewToSnapshot];
+  if ([childComponentView isKindOfClass:[RNSScreenStackHeaderConfigComponentView class]]) {
+    _config = nil;
+  }
+  [super unmountChildComponentView:childComponentView index:index];
+}
+
+- (void)updateBounds
+{
+  if (_state != nullptr) {
+    auto boundsSize = self.bounds.size;
+    auto newState = RNSScreenState{RCTSizeFromCGSize(boundsSize)};
+    _state->updateState(std::move(newState));
+    UINavigationController *navctr = _controller.navigationController;
+    [navctr.view setNeedsLayout];
+  }
+}
+
+- (UIView *)reactSuperview
+{
+  return _reactSuperview;
+}
+
+- (void)notifyWillAppear
+{
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const RNSScreenEventEmitter>(_eventEmitter)
+        ->onWillAppear(RNSScreenEventEmitter::OnWillAppear{});
+  }
+}
+
+- (void)notifyWillDisappear
+{
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const RNSScreenEventEmitter>(_eventEmitter)
+        ->onWillDisappear(RNSScreenEventEmitter::OnWillDisappear{});
+  }
+}
+
+- (void)notifyAppear
+{
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const RNSScreenEventEmitter>(_eventEmitter)->onAppear(RNSScreenEventEmitter::OnAppear{});
+  }
+}
+
+- (void)notifyDismissedWithCount:(int)dismissCount
+{
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const RNSScreenEventEmitter>(_eventEmitter)
+        ->onDismissed(RNSScreenEventEmitter::OnDismissed{dismissCount : dismissCount});
+  }
+}
+
+- (void)notifyDisappear
+{
+  // If screen is already unmounted then there will be no event emitter
+  // it will be cleaned in prepareForRecycle
+  if (_eventEmitter != nullptr) {
+    std::dynamic_pointer_cast<const RNSScreenEventEmitter>(_eventEmitter)
+        ->onDisappear(RNSScreenEventEmitter::OnDisappear{});
+  }
+}
+
+#pragma mark - RCTMountingTransactionObserving
+
+- (void)mountingTransactionWillMountWithMetadata:(MountingTransactionMetadata const &)metadata
+{
+  [self.controller takeSnapshot];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  // TODO: Make sure that there is no edge case when this should be uncommented
+  // _controller=nil;
+  _state.reset();
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNSScreenComponentDescriptor>();
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldScreenProps = *std::static_pointer_cast<const RNSScreenProps>(_props);
+  const auto &newScreenProps = *std::static_pointer_cast<const RNSScreenProps>(props);
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateState:(facebook::react::State::Shared const &)state
+           oldState:(facebook::react::State::Shared const &)oldState
+{
+  _state = std::static_pointer_cast<const RNSScreenShadowNode::ConcreteState>(state);
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSScreenCls(void)
+{
+  return RNSScreenComponentView.class;
+}

package/ios/RNSScreenController.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+
+@interface RNSScreenController : UIViewController
+
+- (instancetype)initWithView:(UIView *)view;
+- (void)takeSnapshot;
+- (void)setViewToSnapshot;
+- (void)resetViewToScreen;
+
+@end

package/ios/RNSScreenController.mm

@@ -0,0 +1,79 @@
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#import "RNSScreenComponentView.h"
+
+@implementation RNSScreenController {
+  CGRect _lastViewFrame;
+  RNSScreenComponentView *_initialView;
+  UIView *_snapshot;
+}
+
+- (instancetype)initWithView:(UIView *)view
+{
+  if (self = [super init]) {
+    self.view = view;
+    if ([view isKindOfClass:[RNSScreenComponentView class]]) {
+      _initialView = (RNSScreenComponentView *)view;
+    } else {
+      RCTLogError(@"ScreenController can only be initialized with ScreenComponentView");
+    }
+  }
+  return self;
+}
+
+- (void)takeSnapshot
+{
+  _snapshot = [self.view snapshotViewAfterScreenUpdates:NO];
+}
+
+- (void)setViewToSnapshot
+{
+  [self.view removeFromSuperview];
+  self.view = _snapshot;
+}
+
+- (void)resetViewToScreen
+{
+  [self.view removeFromSuperview];
+  self.view = _initialView;
+}
+
+// TODO: Find out why this is executed when screen is going out
+- (void)viewWillAppear:(BOOL)animated
+{
+  [super viewWillAppear:animated];
+  [_initialView notifyWillAppear];
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+  [super viewWillDisappear:animated];
+  [_initialView notifyWillDisappear];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+  [super viewDidAppear:animated];
+  [_initialView notifyAppear];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [super viewDidDisappear:animated];
+  [_initialView notifyDisappear];
+  if (self.parentViewController == nil && self.presentingViewController == nil) {
+    // screen dismissed, send event
+    [_initialView notifyDismissedWithCount:1];
+  }
+}
+
+- (void)viewDidLayoutSubviews
+{
+  [super viewDidLayoutSubviews];
+  BOOL isDisplayedWithinUINavController = [self.parentViewController isKindOfClass:[UINavigationController class]];
+  if (isDisplayedWithinUINavController && !CGRectEqualToRect(_lastViewFrame, self.view.frame)) {
+    _lastViewFrame = self.view.frame;
+    [_initialView updateBounds];
+  }
+}
+
+@end

package/ios/RNSScreenStack.m

@@ -142,6 +142,10 @@
     // that can handle it when dismissing a modal, the same for orientation
     [RNSScreenWindowTraits updateWindowTraits];
     [_presentedModals removeObject:presentationController.presentedViewController];
+    // we double check if there are no new controllers pending to be presented since someone could
+    // have tried to push another one during the transition
+    _updatingModals = NO;
+    [self updateContainer];
     if (self.onFinishTransitioning) {
       // instead of directly triggering onFinishTransitioning this time we enqueue the event on the
       // main queue. We do that because onDismiss event is also enqueued and we want for the transition
@@ -362,6 +366,14 @@
         BOOL shouldAnimate = lastModal && [next isKindOfClass:[RNSScreen class]] &&
             ((RNSScreenView *)next.view).stackAnimation != RNSScreenStackAnimationNone;
 
+        // if you want to present another modal quick enough after dismissing the previous one,
+        // it will result in wrong changeRootController, see repro in
+        // https://github.com/software-mansion/react-native-screens/issues/1299 We call `updateContainer` again in
+        // `presentationControllerDidDismiss` to cover this case and present new controller
+        if (previous.beingDismissed) {
+          return;
+        }
+
         [previous presentViewController:next
                                animated:shouldAnimate
                              completion:^{

package/ios/RNSScreenStackComponentView.h

@@ -0,0 +1,15 @@
+#import <UIKit/UIKit.h>
+
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSScreenStackComponentView : RCTViewComponentView
+
+@end
+
+@interface RNSScreenStackView : UIView
+- (instancetype)initWithComponentView:(RNSScreenStackComponentView *)component;
+@end
+
+NS_ASSUME_NONNULL_END