@amazon-devices/react-native-screens 2.0.1758683737

package/ios/RNSFullWindowOverlay.mm

@@ -0,0 +1,241 @@
+#import <UIKit/UIKit.h>
+
+#import "RNSFullWindowOverlay.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#import <React/RCTSurfaceTouchHandler.h>
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+#import <react/renderer/components/rnscreens/Props.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#else
+#import <React/RCTTouchHandler.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+@implementation RNSFullWindowOverlayContainer
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    self.accessibilityViewIsModal = YES;
+  }
+  return self;
+}
+
+- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
+{
+  for (UIView *view in [self subviews]) {
+    if (view.userInteractionEnabled && [view pointInside:[self convertPoint:point toView:view] withEvent:event]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  BOOL canReceiveTouchEvents = ([self isUserInteractionEnabled] && ![self isHidden]);
+  if (!canReceiveTouchEvents) {
+    return nil;
+  }
+
+  // `hitSubview` is the topmost subview which was hit. The hit point can
+  // be outside the bounds of `view` (e.g., if -clipsToBounds is NO).
+  UIView *hitSubview = nil;
+  BOOL isPointInside = [self pointInside:point withEvent:event];
+  if (![self clipsToBounds] || isPointInside) {
+    // Take z-index into account when calculating the touch target.
+    NSArray<UIView *> *sortedSubviews = [self reactZIndexSortedSubviews];
+
+    // The default behaviour of UIKit is that if a view does not contain a point,
+    // then no subviews will be returned from hit testing, even if they contain
+    // the hit point. By doing hit testing directly on the subviews, we bypass
+    // the strict containment policy (i.e., UIKit guarantees that every ancestor
+    // of the hit view will return YES from -pointInside:withEvent:). See:
+    //  - https://developer.apple.com/library/ios/qa/qa2013/qa1812.html
+    for (UIView *subview in [sortedSubviews reverseObjectEnumerator]) {
+      CGPoint convertedPoint = [subview convertPoint:point fromView:self];
+      hitSubview = [subview hitTest:convertedPoint withEvent:event];
+      if (hitSubview != nil) {
+        break;
+      }
+    }
+  }
+  return hitSubview;
+}
+
+@end
+
+@implementation RNSFullWindowOverlay {
+  __weak RCTBridge *_bridge;
+  RNSFullWindowOverlayContainer *_container;
+  CGRect _reactFrame;
+#ifdef RCT_NEW_ARCH_ENABLED
+  RCTSurfaceTouchHandler *_touchHandler;
+#else
+  RCTTouchHandler *_touchHandler;
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (instancetype)init
+{
+  if (self = [super init]) {
+    static const auto defaultProps = std::make_shared<const react::RNSFullWindowOverlayProps>();
+    _props = defaultProps;
+    [self _initCommon];
+  }
+  return self;
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _bridge = bridge;
+    [self _initCommon];
+  }
+
+  return self;
+}
+
+- (void)_initCommon
+{
+  _reactFrame = CGRectNull;
+  _container = self.container;
+  [self show];
+}
+
+- (void)addSubview:(UIView *)view
+{
+  [_container addSubview:view];
+}
+
+- (RNSFullWindowOverlayContainer *)container
+{
+  if (_container == nil) {
+    _container = [[RNSFullWindowOverlayContainer alloc] initWithFrame:_reactFrame];
+  }
+
+  return _container;
+}
+
+- (void)show
+{
+  UIWindow *window = RCTSharedApplication().delegate.window;
+  [window addSubview:_container];
+}
+
+- (void)didMoveToSuperview
+{
+  if (self.superview == nil) {
+    if (_container != nil) {
+      [_container removeFromSuperview];
+      [_touchHandler detachFromView:_container];
+    }
+  } else {
+    if (_container != nil) {
+      UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, _container);
+    }
+    if (_touchHandler == nil) {
+#ifdef RCT_NEW_ARCH_ENABLED
+      _touchHandler = [RCTSurfaceTouchHandler new];
+#else
+      _touchHandler = [[RCTTouchHandler alloc] initWithBridge:_bridge];
+#endif
+    }
+    [_touchHandler attachToView:_container];
+  }
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#pragma mark - Fabric Specific
+
+// When the component unmounts we remove it from window's children,
+// so when the component gets recycled we need to add it back.
+- (void)maybeShow
+{
+  UIWindow *window = RCTSharedApplication().delegate.window;
+  if (![[window subviews] containsObject:self]) {
+    [window addSubview:_container];
+  }
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSFullWindowOverlayComponentDescriptor>();
+}
+
+- (void)prepareForRecycle
+{
+  [_container removeFromSuperview];
+  // Due to view recycling we don't really want to set _container = nil
+  // as it won't be instantiated when the component appears for the second time.
+  // We could consider nulling in here & using container (lazy getter) everywhere else.
+  // _container = nil;
+  [super prepareForRecycle];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  // When the component unmounts we remove it from window's children,
+  // so when the component gets recycled we need to add it back.
+  // As for now it is called here as we lack of method that is called
+  // just before component gets restored (from recycle pool).
+  [self maybeShow];
+  [self addSubview:childComponentView];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateLayoutMetrics:(react::LayoutMetrics const &)layoutMetrics
+           oldLayoutMetrics:(react::LayoutMetrics const &)oldLayoutMetrics
+{
+  CGRect frame = RCTCGRectFromRect(layoutMetrics.frame);
+  _reactFrame = frame;
+  [_container setFrame:frame];
+}
+
+#else
+#pragma mark - Paper specific
+
+- (void)reactSetFrame:(CGRect)frame
+{
+  _reactFrame = frame;
+  [_container setFrame:frame];
+}
+
+- (void)invalidate
+{
+  [_container removeFromSuperview];
+  _container = nil;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+Class<RCTComponentViewProtocol> RNSFullWindowOverlayCls(void)
+{
+  return RNSFullWindowOverlay.class;
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@implementation RNSFullWindowOverlayManager
+
+RCT_EXPORT_MODULE()
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#else
+- (UIView *)view
+{
+  return [[RNSFullWindowOverlay alloc] initWithBridge:self.bridge];
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/ios/RNSScreen.h

@@ -0,0 +1,144 @@
+#import <React/RCTComponent.h>
+#import <React/RCTViewManager.h>
+
+#import "RNSEnums.h"
+#import "RNSScreenContainer.h"
+
+#if RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#else
+#import <React/RCTView.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef RCT_NEW_ARCH_ENABLED
+namespace react = facebook::react;
+#endif // RCT_NEW_ARCH_ENABLED
+
+@interface RCTConvert (RNSScreen)
+
++ (RNSScreenStackPresentation)RNSScreenStackPresentation:(id)json;
++ (RNSScreenStackAnimation)RNSScreenStackAnimation:(id)json;
+
+#if !TARGET_OS_TV
++ (RNSStatusBarStyle)RNSStatusBarStyle:(id)json;
++ (UIStatusBarAnimation)UIStatusBarAnimation:(id)json;
++ (UIInterfaceOrientationMask)UIInterfaceOrientationMask:(id)json;
+#endif
+
+@end
+
+@class RNSScreenView;
+
+@interface RNSScreen : UIViewController <RNSViewControllerDelegate>
+
+- (instancetype)initWithView:(UIView *)view;
+- (UIViewController *)findChildVCForConfigAndTrait:(RNSWindowTrait)trait includingModals:(BOOL)includingModals;
+- (BOOL)hasNestedStack;
+- (void)calculateAndNotifyHeaderHeightChangeIsModal:(BOOL)isModal;
+- (void)notifyFinishTransitioning;
+- (RNSScreenView *)screenView;
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)setViewToSnapshot:(UIView *)snapshot;
+- (void)resetViewToScreen;
+#endif
+
+@end
+
+@class RNSScreenStackHeaderConfig;
+
+@interface RNSScreenView :
+#ifdef RCT_NEW_ARCH_ENABLED
+    RCTViewComponentView
+#else
+    RCTView
+#endif
+
+@property (nonatomic) BOOL fullScreenSwipeEnabled;
+@property (nonatomic) BOOL gestureEnabled;
+@property (nonatomic) BOOL hasStatusBarHiddenSet;
+@property (nonatomic) BOOL hasStatusBarStyleSet;
+@property (nonatomic) BOOL hasStatusBarAnimationSet;
+@property (nonatomic) BOOL hasHomeIndicatorHiddenSet;
+@property (nonatomic) BOOL hasOrientationSet;
+@property (nonatomic) RNSScreenStackAnimation stackAnimation;
+@property (nonatomic) RNSScreenStackPresentation stackPresentation;
+@property (nonatomic) RNSScreenSwipeDirection swipeDirection;
+@property (nonatomic) RNSScreenReplaceAnimation replaceAnimation;
+
+@property (nonatomic, retain) NSNumber *transitionDuration;
+@property (nonatomic, readonly) BOOL dismissed;
+@property (nonatomic) BOOL hideKeyboardOnSwipe;
+@property (nonatomic) BOOL customAnimationOnSwipe;
+@property (nonatomic) BOOL preventNativeDismiss;
+@property (nonatomic, retain) RNSScreen *controller;
+@property (nonatomic, copy) NSDictionary *gestureResponseDistance;
+@property (nonatomic) int activityState;
+@property (weak, nonatomic) UIView<RNSScreenContainerDelegate> *reactSuperview;
+
+#if !TARGET_OS_TV
+@property (nonatomic) RNSStatusBarStyle statusBarStyle;
+@property (nonatomic) UIStatusBarAnimation statusBarAnimation;
+@property (nonatomic) UIInterfaceOrientationMask screenOrientation;
+@property (nonatomic) BOOL statusBarHidden;
+@property (nonatomic) BOOL homeIndicatorHidden;
+
+// Props controlling UISheetPresentationController
+@property (nonatomic) RNSScreenDetentType sheetAllowedDetents;
+@property (nonatomic) RNSScreenDetentType sheetLargestUndimmedDetent;
+@property (nonatomic) BOOL sheetGrabberVisible;
+@property (nonatomic) CGFloat sheetCornerRadius;
+@property (nonatomic) BOOL sheetExpandsWhenScrolledToEdge;
+#endif // !TARGET_OS_TV
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// we recreate the behavior of `reactSetFrame` on new architecture
+@property (nonatomic) react::LayoutMetrics oldLayoutMetrics;
+@property (nonatomic) react::LayoutMetrics newLayoutMetrics;
+@property (weak, nonatomic) RNSScreenStackHeaderConfig *config;
+@property (nonatomic, readonly) BOOL hasHeaderConfig;
+#else
+@property (nonatomic, copy) RCTDirectEventBlock onAppear;
+@property (nonatomic, copy) RCTDirectEventBlock onDisappear;
+@property (nonatomic, copy) RCTDirectEventBlock onDismissed;
+@property (nonatomic, copy) RCTDirectEventBlock onHeaderHeightChange;
+@property (nonatomic, copy) RCTDirectEventBlock onWillAppear;
+@property (nonatomic, copy) RCTDirectEventBlock onWillDisappear;
+@property (nonatomic, copy) RCTDirectEventBlock onNativeDismissCancelled;
+@property (nonatomic, copy) RCTDirectEventBlock onTransitionProgress;
+@property (nonatomic, copy) RCTDirectEventBlock onGestureCancel;
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (void)notifyFinishTransitioning;
+- (void)notifyHeaderHeightChange:(double)height;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)notifyWillAppear;
+- (void)notifyWillDisappear;
+- (void)notifyAppear;
+- (void)notifyDisappear;
+- (void)updateBounds;
+- (void)notifyDismissedWithCount:(int)dismissCount;
+- (instancetype)initWithFrame:(CGRect)frame;
+#endif
+
+- (void)notifyTransitionProgress:(double)progress closing:(BOOL)closing goingForward:(BOOL)goingForward;
+- (void)notifyDismissCancelledWithDismissCount:(int)dismissCount;
+- (BOOL)isModal;
+- (BOOL)isPresentedAsNativeModal;
+
+/// Looks for header configuration in instance's `reactSubviews` and returns it. If not present returns `nil`.
+- (RNSScreenStackHeaderConfig *_Nullable)findHeaderConfig;
+
+@end
+
+@interface UIView (RNSScreen)
+- (UIViewController *)parentViewController;
+@end
+
+@interface RNSScreenManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END