react-native-screens 3.10.1 → 3.12.0

package/ios/RNSScreenStackComponentView.mm

@@ -0,0 +1,295 @@
+#import "RNSScreenStackComponentView.h"
+#import "RNSScreenComponentView.h"
+#import "RNSScreenStackHeaderConfigComponentView.h"
+
+#import <React/UIView+React.h>
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+@interface RNSScreenStackComponentView () <
+    UINavigationControllerDelegate,
+    UIAdaptivePresentationControllerDelegate,
+    UIGestureRecognizerDelegate,
+    UIViewControllerTransitioningDelegate>
+@end
+
+@implementation RNSScreenStackComponentView {
+  UINavigationController *_controller;
+  NSMutableArray<RNSScreenComponentView *> *_reactSubviews;
+  BOOL _invalidated;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNSScreenStackProps>();
+    _props = defaultProps;
+    _reactSubviews = [NSMutableArray new];
+    _controller = [[UINavigationController alloc] init];
+    _controller.delegate = self;
+    [_controller setViewControllers:@[ [UIViewController new] ]];
+    _invalidated = NO;
+  }
+
+  return self;
+}
+
+- (void)markChildUpdated
+{
+  // do nothing
+}
+
+- (void)didUpdateChildren
+{
+  // do nothing
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  if (![childComponentView isKindOfClass:[RNSScreenComponentView class]]) {
+    RCTLogError(@"ScreenStack only accepts children of type Screen");
+    return;
+  }
+
+  RCTAssert(
+      childComponentView.reactSuperview == nil,
+      @"Attempt to mount already mounted component view. (parent: %@, child: %@, index: %@, existing parent: %@)",
+      self,
+      childComponentView,
+      @(index),
+      @([childComponentView.superview tag]));
+
+  [_reactSubviews insertObject:(RNSScreenComponentView *)childComponentView atIndex:index];
+  ((RNSScreenComponentView *)childComponentView).reactSuperview = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self maybeAddToParentAndUpdateContainer];
+  });
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  RNSScreenComponentView *screenChildComponent = (RNSScreenComponentView *)childComponentView;
+  RCTAssert(
+      screenChildComponent.reactSuperview == self,
+      @"Attempt to unmount a view which is mounted inside different view. (parent: %@, child: %@, index: %@)",
+      self,
+      screenChildComponent,
+      @(index));
+  RCTAssert(
+      (_reactSubviews.count > index) && [_reactSubviews objectAtIndex:index] == childComponentView,
+      @"Attempt to unmount a view which has a different index. (parent: %@, child: %@, index: %@, actual index: %@, tag at index: %@)",
+      self,
+      screenChildComponent,
+      @(index),
+      @([_reactSubviews indexOfObject:screenChildComponent]),
+      @([[_reactSubviews objectAtIndex:index] tag]));
+  screenChildComponent.reactSuperview = nil;
+  [_reactSubviews removeObject:screenChildComponent];
+  [screenChildComponent removeFromSuperview];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self maybeAddToParentAndUpdateContainer];
+  });
+}
+
+- (NSArray<UIView *> *)reactSubviews
+{
+  return _reactSubviews;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  if (!_invalidated) {
+    [self maybeAddToParentAndUpdateContainer];
+  }
+}
+
+- (void)navigationController:(UINavigationController *)navigationController
+      willShowViewController:(UIViewController *)viewController
+                    animated:(BOOL)animated
+{
+  UIView *view = viewController.view;
+  if ([view isKindOfClass:RNSScreenComponentView.class]) {
+    RNSScreenStackHeaderConfigComponentView *config =
+        (RNSScreenStackHeaderConfigComponentView *)((RNSScreenComponentView *)view).config;
+    [RNSScreenStackHeaderConfigComponentView willShowViewController:viewController animated:animated withConfig:config];
+  }
+}
+
+- (void)maybeAddToParentAndUpdateContainer
+{
+  BOOL wasScreenMounted = _controller.parentViewController != nil;
+  BOOL isScreenReadyForShowing = self.window;
+  if (!isScreenReadyForShowing && !wasScreenMounted) {
+    return;
+  }
+  [self updateContainer];
+  if (!wasScreenMounted) {
+    // when stack hasn't been added to parent VC yet we do two things:
+    // 1) we run updateContainer (the one above) – we do this because we want push view controllers to
+    // be installed before the VC is mounted. If we do that after it is added to parent the push
+    // updates operations are going to be blocked by UIKit.
+    // 2) we add navigation VS to parent – this is needed for the VC lifecycle events to be dispatched
+    // properly
+    // 3) we again call updateContainer – this time we do this to open modal controllers. Modals
+    // won't open in (1) because they require navigator to be added to parent. We handle that case
+    // gracefully in setModalViewControllers and can retry opening at any point.
+    [self reactAddControllerToClosestParent:_controller];
+    [self updateContainer];
+  }
+}
+
+- (void)reactAddControllerToClosestParent:(UIViewController *)controller
+{
+  if (!controller.parentViewController) {
+    UIView *parentView = (UIView *)self.reactSuperview;
+    while (parentView) {
+      if ([parentView reactViewController]) {
+        [parentView.reactViewController addChildViewController:controller];
+        [self addSubview:controller.view];
+#if !TARGET_OS_TV
+        _controller.interactivePopGestureRecognizer.delegate = self;
+#endif
+        [self navigationController:_controller willShowViewController:_controller.topViewController animated:NO];
+      }
+      parentView = (UIView *)parentView.reactSuperview;
+    }
+    return;
+  }
+}
+
+- (void)setPushViewControllers:(NSArray<UIViewController *> *)controllers
+{
+  // when there is no change we return immediately
+  if ([_controller.viewControllers isEqualToArray:controllers]) {
+    return;
+  }
+
+  // if view controller is not yet attached to window we skip updates now and run them when view
+  // is attached
+  if (self.window == nil) {
+    return;
+  }
+
+  UIViewController *top = controllers.lastObject;
+  UIViewController *lastTop = _controller.viewControllers.lastObject;
+
+  // at the start we set viewControllers to contain a single UIVIewController
+  // instance. This is a workaround for header height adjustment bug (see comment
+  // in the init function). Here, we need to detect if the initial empty
+  // controller is still there
+  BOOL firstTimePush = ![lastTop isKindOfClass:[RNSScreenController class]];
+
+  BOOL shouldAnimate = YES;
+
+  if (firstTimePush) {
+    // nothing pushed yet
+    [_controller setViewControllers:controllers animated:NO];
+  } else if (top != lastTop) {
+    if (![controllers containsObject:lastTop]) {
+      // if the previous top screen does not exist anymore and the new top was not on the stack before, probably replace
+      // was called, so we check the animation
+      if (![_controller.viewControllers containsObject:top]) {
+        // setting new controllers with animation does `push` animation by default
+        auto screenController = (RNSScreenController *)top;
+        [screenController resetViewToScreen];
+        [_controller setViewControllers:controllers animated:YES];
+      } else {
+        // last top controller is no longer on stack
+        // in this case we set the controllers stack to the new list with
+        // added the last top element to it and perform (animated) pop
+        NSMutableArray *newControllers = [NSMutableArray arrayWithArray:controllers];
+        [newControllers addObject:lastTop];
+        [_controller setViewControllers:newControllers animated:NO];
+        [_controller popViewControllerAnimated:shouldAnimate];
+      }
+    } else if (![_controller.viewControllers containsObject:top]) {
+      // new top controller is not on the stack
+      // in such case we update the stack except from the last element with
+      // no animation and do animated push of the last item
+      NSMutableArray *newControllers = [NSMutableArray arrayWithArray:controllers];
+      [newControllers removeLastObject];
+      [_controller setViewControllers:newControllers animated:NO];
+      auto screenController = (RNSScreenController *)top;
+      [screenController resetViewToScreen];
+      [_controller pushViewController:top animated:shouldAnimate];
+    } else {
+      // don't really know what this case could be, but may need to handle it
+      // somehow
+      [_controller setViewControllers:controllers animated:shouldAnimate];
+    }
+  } else {
+    // change wasn't on the top of the stack. We don't need animation.
+    [_controller setViewControllers:controllers animated:NO];
+  }
+}
+
+- (void)updateContainer
+{
+  NSMutableArray<UIViewController *> *pushControllers = [NSMutableArray new];
+  for (RNSScreenComponentView *screen in _reactSubviews) {
+    if (screen.controller != nil) {
+      if (pushControllers.count == 0) {
+        // first screen on the list needs to be places as "push controller"
+        [pushControllers addObject:screen.controller];
+      } else {
+        [pushControllers addObject:screen.controller];
+      }
+    }
+  }
+
+  [self setPushViewControllers:pushControllers];
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  _controller.view.frame = self.bounds;
+}
+
+- (void)invalidate
+{
+  _invalidated = YES;
+  [_controller willMoveToParentViewController:nil];
+  [_controller removeFromParentViewController];
+}
+
+- (void)dismissOnReload
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self invalidate];
+  });
+}
+
+#pragma mark methods connected to transitioning
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+  return YES;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+  _reactSubviews = [NSMutableArray new];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNSScreenStackComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNSScreenStackCls(void)
+{
+  return RNSScreenStackComponentView.class;
+}

package/ios/RNSScreenStackHeaderConfig.m

@@ -152,9 +152,12 @@
     nextVC = nav.topViewController;
   }
 
+  // we want updates sent to the VC below modal too since it is also visible
+  BOOL isPresentingVC = vc.presentedViewController == nextVC;
+
   BOOL isInFullScreenModal = nav == nil && _screenView.stackPresentation == RNSScreenStackPresentationFullScreenModal;
   // if nav is nil, it means we can be in a fullScreen modal, so there is no nextVC, but we still want to update
-  if (vc != nil && (nextVC == vc || isInFullScreenModal)) {
+  if (vc != nil && (nextVC == vc || isInFullScreenModal || isPresentingVC)) {
     [RNSScreenStackHeaderConfig updateViewController:self.screenView.controller withConfig:self animated:YES];
   }
 }

package/ios/RNSScreenStackHeaderConfigComponentView.h

@@ -0,0 +1,42 @@
+#import <UIKit/UIKit.h>
+
+#import <React/RCTViewComponentView.h>
+
+#import "RNSScreenComponentView.h"
+#import "RNSScreenStackHeaderSubviewComponentView.h"
+
+@interface RNSScreenStackHeaderConfigComponentView : RCTViewComponentView
+
+@property (nonatomic, weak) RNSScreenComponentView *screenView;
+@property (nonatomic) NSMutableArray<RNSScreenStackHeaderSubviewComponentView *> *reactSubviews;
+
+// Properties from props
+@property (nonatomic) BOOL show;
+@property (nonatomic) BOOL translucent;
+@property (nonatomic) BOOL hideShadow;
+@property (nonatomic, retain) NSString *title;
+@property (nonatomic, retain) NSString *titleFontFamily;
+@property (nonatomic, retain) NSNumber *titleFontSize;
+@property (nonatomic, retain) NSString *titleFontWeight;
+@property (nonatomic, retain) UIColor *titleColor;
+@property (nonatomic) BOOL largeTitle;
+@property (nonatomic, retain) NSString *largeTitleFontFamily;
+@property (nonatomic, retain) NSNumber *largeTitleFontSize;
+@property (nonatomic, retain) NSString *largeTitleFontWeight;
+@property (nonatomic, retain) UIColor *largeTitleBackgroundColor;
+@property (nonatomic) BOOL largeTitleHideShadow;
+@property (nonatomic, retain) UIColor *largeTitleColor;
+@property (nonatomic, retain) UIColor *backgroundColor;
+@property (nonatomic, retain) UIColor *color;
+@property (nonatomic) UISemanticContentAttribute direction;
+@property (nonatomic, retain) NSString *backTitle;
+@property (nonatomic, retain) NSString *backTitleFontFamily;
+@property (nonatomic, retain) NSNumber *backTitleFontSize;
+@property (nonatomic) BOOL disableBackButtonMenu;
+@property (nonatomic) BOOL hideBackButton;
+
++ (void)willShowViewController:(UIViewController *)vc
+                      animated:(BOOL)animated
+                    withConfig:(RNSScreenStackHeaderConfigComponentView *)config;
+
+@end