react-native-screens 3.10.1 → 3.12.0

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/RNSScreenContainer.m

@@ -23,6 +23,11 @@
 {
   return [self findActiveChildVC].supportedInterfaceOrientations;
 }
+
+- (UIViewController *)childViewControllerForHomeIndicatorAutoHidden
+{
+  return [self findActiveChildVC];
+}
 #endif
 
 - (UIViewController *)findActiveChildVC

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

@@ -45,6 +45,11 @@
 {
   return [self topViewController].supportedInterfaceOrientations;
 }
+
+- (UIViewController *)childViewControllerForHomeIndicatorAutoHidden
+{
+  return [self topViewController];
+}
 #endif
 
 @end
@@ -645,13 +650,23 @@
 
 - (void)handleSwipe:(UIPanGestureRecognizer *)gestureRecognizer
 {
-  float translation = [gestureRecognizer translationInView:gestureRecognizer.view].x;
-  float velocity = [gestureRecognizer velocityInView:gestureRecognizer.view].x;
-  float distance = gestureRecognizer.view.bounds.size.width;
-  BOOL isRTL = _controller.view.semanticContentAttribute == UISemanticContentAttributeForceRightToLeft;
-  if (isRTL) {
-    translation = -translation;
-    velocity = -velocity;
+  RNSScreenView *topScreen = (RNSScreenView *)_controller.viewControllers.lastObject.view;
+  float translation;
+  float velocity;
+  float distance;
+  if (topScreen.swipeDirection == RNSScreenSwipeDirectionVertical) {
+    translation = [gestureRecognizer translationInView:gestureRecognizer.view].y;
+    velocity = [gestureRecognizer velocityInView:gestureRecognizer.view].y;
+    distance = gestureRecognizer.view.bounds.size.height;
+  } else {
+    translation = [gestureRecognizer translationInView:gestureRecognizer.view].x;
+    velocity = [gestureRecognizer velocityInView:gestureRecognizer.view].x;
+    distance = gestureRecognizer.view.bounds.size.width;
+    BOOL isRTL = _controller.view.semanticContentAttribute == UISemanticContentAttributeForceRightToLeft;
+    if (isRTL) {
+      translation = -translation;
+      velocity = -velocity;
+    }
   }
 
   float transitionProgress = (translation / distance);

package/ios/RNSScreenStackAnimator.m

@@ -2,6 +2,13 @@
 #import "RNSScreen.h"
 #import "RNSScreenStack.h"
 
+// proportions to default transition duration
+static const float RNSSlideOpenTransitionDurationProportion = 1;
+static const float RNSFadeOpenTransitionDurationProportion = 0.2 / 0.35;
+static const float RNSSlideCloseTransitionDurationProportion = 0.25 / 0.35;
+static const float RNSFadeCloseTransitionDurationProportion = 0.15 / 0.35;
+static const float RNSFadeCloseDelayTransitionDurationProportion = 0.1 / 0.35;
+
 @implementation RNSScreenStackAnimator {
   UINavigationControllerOperation _operation;
   NSTimeInterval _transitionDuration;
@@ -11,7 +18,7 @@
 {
   if (self = [super init]) {
     _operation = operation;
-    _transitionDuration = 0.35; // default duration
+    _transitionDuration = 0.35; // default duration in seconds
   }
   return self;
 }
@@ -32,6 +39,12 @@
   if (screen != nil && screen.stackAnimation == RNSScreenStackAnimationNone) {
     return 0;
   }
+
+  if (screen != nil && screen.transitionDuration != nil && [screen.transitionDuration floatValue] >= 0) {
+    float durationInSeconds = [screen.transitionDuration floatValue] / 1000.0;
+    return durationInSeconds;
+  }
+
   return _transitionDuration;
 }
 
@@ -184,14 +197,30 @@
   } else if (_operation == UINavigationControllerOperationPop) {
     toViewController.view.transform = CGAffineTransformIdentity;
     [[transitionContext containerView] insertSubview:toViewController.view belowSubview:fromViewController.view];
-    [UIView animateWithDuration:[self transitionDuration:transitionContext]
-        animations:^{
-          toViewController.view.transform = CGAffineTransformIdentity;
-          fromViewController.view.transform = topBottomTransform;
-        }
-        completion:^(BOOL finished) {
-          [transitionContext completeTransition:![transitionContext transitionWasCancelled]];
-        }];
+
+    void (^animationBlock)(void) = ^{
+      toViewController.view.transform = CGAffineTransformIdentity;
+      fromViewController.view.transform = topBottomTransform;
+    };
+    void (^completionBlock)(BOOL) = ^(BOOL finished) {
+      if (transitionContext.transitionWasCancelled) {
+        toViewController.view.transform = CGAffineTransformIdentity;
+      }
+      [transitionContext completeTransition:![transitionContext transitionWasCancelled]];
+    };
+
+    if (!transitionContext.isInteractive) {
+      [UIView animateWithDuration:[self transitionDuration:transitionContext]
+                       animations:animationBlock
+                       completion:completionBlock];
+    } else {
+      // we don't want the EaseInOut option when swiping to dismiss the view, it is the same in default animation option
+      [UIView animateWithDuration:[self transitionDuration:transitionContext]
+                            delay:0.0
+                          options:UIViewAnimationOptionCurveLinear
+                       animations:animationBlock
+                       completion:completionBlock];
+    }
   }
 }
 
@@ -202,6 +231,8 @@
   CGAffineTransform topBottomTransform =
       CGAffineTransformMakeTranslation(0, 0.08 * transitionContext.containerView.bounds.size.height);
 
+  const float transitionDuration = [self transitionDuration:transitionContext];
+
   if (_operation == UINavigationControllerOperationPush) {
     toViewController.view.transform = topBottomTransform;
     toViewController.view.alpha = 0.0;
@@ -209,7 +240,7 @@
 
     // Android Nougat open animation
     // http://aosp.opersys.com/xref/android-7.1.2_r37/xref/frameworks/base/core/res/res/anim/activity_open_enter.xml
-    [UIView animateWithDuration:0.35
+    [UIView animateWithDuration:transitionDuration * RNSSlideOpenTransitionDurationProportion // defaults to 0.35 s
         delay:0
         options:UIViewAnimationOptionCurveEaseOut
         animations:^{
@@ -220,7 +251,7 @@
           fromViewController.view.transform = CGAffineTransformIdentity;
           [transitionContext completeTransition:![transitionContext transitionWasCancelled]];
         }];
-    [UIView animateWithDuration:0.2
+    [UIView animateWithDuration:transitionDuration * RNSFadeOpenTransitionDurationProportion // defaults to 0.2 s
                           delay:0
                         options:UIViewAnimationOptionCurveEaseOut
                      animations:^{
@@ -234,7 +265,7 @@
 
     // Android Nougat exit animation
     // http://aosp.opersys.com/xref/android-7.1.2_r37/xref/frameworks/base/core/res/res/anim/activity_close_exit.xml
-    [UIView animateWithDuration:0.25
+    [UIView animateWithDuration:transitionDuration * RNSSlideCloseTransitionDurationProportion // defaults to 0.25 s
         delay:0
         options:UIViewAnimationOptionCurveEaseIn
         animations:^{
@@ -244,8 +275,8 @@
         completion:^(BOOL finished) {
           [transitionContext completeTransition:![transitionContext transitionWasCancelled]];
         }];
-    [UIView animateWithDuration:0.15
-                          delay:0.1
+    [UIView animateWithDuration:transitionDuration * RNSFadeCloseTransitionDurationProportion // defaults to 0.15 s
+                          delay:transitionDuration * RNSFadeCloseDelayTransitionDurationProportion // defaults to 0.1 s
                         options:UIViewAnimationOptionCurveLinear
                      animations:^{
                        fromViewController.view.alpha = 0.0;

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