@amazon-devices/react-native-screens 2.0.1758683737

package/ios/RNSScreenStackHeaderSubview.h

@@ -0,0 +1,44 @@
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#endif
+
+#import <React/RCTConvert.h>
+#import <React/RCTViewManager.h>
+#import "RNSEnums.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSScreenStackHeaderSubview :
+#ifdef RCT_NEW_ARCH_ENABLED
+    RCTViewComponentView
+#else
+    UIView
+#endif
+
+@property (nonatomic) RNSScreenStackHeaderSubviewType type;
+
+@property (nonatomic, weak) UIView *reactSuperview;
+
+@property (nonatomic, weak) RCTBridge *bridge;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#else
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end
+
+@interface RNSScreenStackHeaderSubviewManager : RCTViewManager
+
+@property (nonatomic) RNSScreenStackHeaderSubviewType type;
+
+@end
+
+@interface RCTConvert (RNSScreenStackHeaderSubview)
+
++ (RNSScreenStackHeaderSubviewType)RNSScreenStackHeaderSubviewType:(id)json;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNSScreenStackHeaderSubview.mm

@@ -0,0 +1,147 @@
+#import "RNSScreenStackHeaderSubview.h"
+#import "RNSConvert.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#ifdef RCT_NEW_ARCH_ENABLED
+namespace react = facebook::react;
+#endif // RCT_NEW_ARCH_ENABLED
+
+@interface RCTBridge (Private)
++ (RCTBridge *)currentBridge;
+@end
+
+@implementation RNSScreenStackHeaderSubview
+
+#pragma mark - Common
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#pragma mark - Fabric specific
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const react::RNSScreenStackHeaderSubviewProps>();
+    _props = defaultProps;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+}
+
+- (void)updateProps:(react::Props::Shared const &)props oldProps:(react::Props::Shared const &)oldProps
+{
+  const auto &newHeaderSubviewProps = *std::static_pointer_cast<const react::RNSScreenStackHeaderSubviewProps>(props);
+
+  [self setType:[RNSConvert RNSScreenStackHeaderSubviewTypeFromCppEquivalent:newHeaderSubviewProps.type]];
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSScreenStackHeaderSubviewComponentDescriptor>();
+}
+
+- (void)updateLayoutMetrics:(const react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const react::LayoutMetrics &)oldLayoutMetrics
+{
+  CGRect frame = RCTCGRectFromRect(layoutMetrics.frame);
+  // CALayer will crash if we pass NaN or Inf values.
+  // It's unclear how to detect this case on cross-platform manner holistically, so we have to do it on the mounting
+  // layer as well. NaN/Inf is a kinda valid result of some math operations. Even if we can (and should) detect (and
+  // report early) incorrect (NaN and Inf) values which come from JavaScript side, we sometimes cannot backtrace the
+  // sources of a calculation that produced an incorrect/useless result.
+  if (!std::isfinite(frame.size.width) || !std::isfinite(frame.size.height)) {
+    RCTLogWarn(
+        @"-[UIView(ComponentViewProtocol) updateLayoutMetrics:oldLayoutMetrics:]: Received invalid layout metrics (%@) for a view (%@).",
+        NSStringFromCGRect(frame),
+        self);
+  } else {
+    self.bounds = CGRect{CGPointZero, frame.size};
+  }
+}
+
+#else
+#pragma mark - Paper specific
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if (self = [super init]) {
+    _bridge = bridge;
+  }
+  return self;
+}
+
+- (void)reactSetFrame:(CGRect)frame
+{
+  // Block any attempt to set coordinates on RNSScreenStackHeaderSubview. This
+  // makes UINavigationBar the only one to control the position of header content.
+  [super reactSetFrame:CGRectMake(0, 0, frame.size.width, frame.size.height)];
+}
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (RCTBridge *)bridge
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  return [RCTBridge currentBridge];
+#else
+  return _bridge;
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+@end
+
+@implementation RNSScreenStackHeaderSubviewManager
+
+RCT_EXPORT_MODULE()
+
+RCT_EXPORT_VIEW_PROPERTY(type, RNSScreenStackHeaderSubviewType)
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#else
+- (UIView *)view
+{
+  return [[RNSScreenStackHeaderSubview alloc] initWithBridge:self.bridge];
+}
+#endif
+
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+Class<RCTComponentViewProtocol> RNSScreenStackHeaderSubviewCls(void)
+{
+  return RNSScreenStackHeaderSubview.class;
+}
+#endif
+
+@implementation RCTConvert (RNSScreenStackHeaderSubview)
+
+RCT_ENUM_CONVERTER(
+    RNSScreenStackHeaderSubviewType,
+    (@{
+      @"back" : @(RNSScreenStackHeaderSubviewTypeBackButton),
+      @"left" : @(RNSScreenStackHeaderSubviewTypeLeft),
+      @"right" : @(RNSScreenStackHeaderSubviewTypeRight),
+      @"title" : @(RNSScreenStackHeaderSubviewTypeTitle),
+      @"center" : @(RNSScreenStackHeaderSubviewTypeCenter),
+      @"searchBar" : @(RNSScreenStackHeaderSubviewTypeSearchBar),
+    }),
+    RNSScreenStackHeaderSubviewTypeTitle,
+    integerValue)
+
+@end

package/ios/RNSScreenWindowTraits.h

@@ -0,0 +1,26 @@
+#import "RNSScreen.h"
+
+@interface RNSScreenWindowTraits : NSObject
+
++ (void)updateWindowTraits;
+
+#if !TARGET_OS_TV
++ (void)assertViewControllerBasedStatusBarAppearenceSet;
+#endif
++ (void)updateStatusBarAppearance;
++ (void)enforceDesiredDeviceOrientation;
++ (void)updateHomeIndicatorAutoHidden;
+
+#if !TARGET_OS_TV
++ (UIStatusBarStyle)statusBarStyleForRNSStatusBarStyle:(RNSStatusBarStyle)statusBarStyle;
++ (UIInterfaceOrientation)defaultOrientationForOrientationMask:(UIInterfaceOrientationMask)orientationMask;
++ (UIInterfaceOrientation)interfaceOrientationFromDeviceOrientation:(UIDeviceOrientation)deviceOrientation;
++ (UIInterfaceOrientationMask)maskFromOrientation:(UIInterfaceOrientation)orientation;
+#endif
+
++ (BOOL)shouldAskScreensForTrait:(RNSWindowTrait)trait
+                 includingModals:(BOOL)includingModals
+                inViewController:(UIViewController *)vc;
++ (BOOL)shouldAskScreensForScreenOrientationInViewController:(UIViewController *)vc;
+
+@end

package/ios/RNSScreenWindowTraits.mm

@@ -0,0 +1,266 @@
+#import "RNSScreenWindowTraits.h"
+#import "RNSScreenContainer.h"
+#import "RNSScreenStack.h"
+
+@implementation RNSScreenWindowTraits
+
+#if !TARGET_OS_TV
++ (void)assertViewControllerBasedStatusBarAppearenceSet
+{
+  static dispatch_once_t once;
+  static bool viewControllerBasedAppearence;
+  dispatch_once(&once, ^{
+    viewControllerBasedAppearence =
+        [[[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIViewControllerBasedStatusBarAppearance"] boolValue];
+  });
+  if (!viewControllerBasedAppearence) {
+    RCTLogError(@"If you want to change the appearance of status bar, you have to change \
+    UIViewControllerBasedStatusBarAppearance key in the Info.plist to YES");
+  }
+}
+#endif
+
++ (void)updateStatusBarAppearance
+{
+#if !TARGET_OS_TV
+  [UIView animateWithDuration:0.4
+                   animations:^{ // duration based on "Programming iOS 13" p. 311 implementation
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+                     if (@available(iOS 13, *)) {
+                       UIWindow *firstWindow = [[[UIApplication sharedApplication] windows] firstObject];
+                       if (firstWindow != nil) {
+                         [[firstWindow rootViewController] setNeedsStatusBarAppearanceUpdate];
+                       }
+                     } else
+#endif
+                     {
+                       [UIApplication.sharedApplication.keyWindow.rootViewController setNeedsStatusBarAppearanceUpdate];
+                     }
+                   }];
+#endif
+}
+
++ (void)updateHomeIndicatorAutoHidden
+{
+#if !TARGET_OS_TV
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+  if (@available(iOS 13, *)) {
+    UIWindow *firstWindow = [[[UIApplication sharedApplication] windows] firstObject];
+    if (firstWindow != nil) {
+      [[firstWindow rootViewController] setNeedsUpdateOfHomeIndicatorAutoHidden];
+    }
+  } else
+#endif
+  {
+    if (@available(iOS 11.0, *)) {
+      [UIApplication.sharedApplication.keyWindow.rootViewController setNeedsUpdateOfHomeIndicatorAutoHidden];
+    }
+  }
+#endif
+}
+
+#if !TARGET_OS_TV
++ (UIStatusBarStyle)statusBarStyleForRNSStatusBarStyle:(RNSStatusBarStyle)statusBarStyle
+{
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+  if (@available(iOS 13.0, *)) {
+    switch (statusBarStyle) {
+      case RNSStatusBarStyleAuto:
+        return [UITraitCollection.currentTraitCollection userInterfaceStyle] == UIUserInterfaceStyleDark
+            ? UIStatusBarStyleLightContent
+            : UIStatusBarStyleDarkContent;
+      case RNSStatusBarStyleInverted:
+        return [UITraitCollection.currentTraitCollection userInterfaceStyle] == UIUserInterfaceStyleDark
+            ? UIStatusBarStyleDarkContent
+            : UIStatusBarStyleLightContent;
+      case RNSStatusBarStyleLight:
+        return UIStatusBarStyleLightContent;
+      case RNSStatusBarStyleDark:
+        return UIStatusBarStyleDarkContent;
+      default:
+        return UIStatusBarStyleLightContent;
+    }
+  }
+#endif
+  // it is the only non-default style available for iOS < 13
+  if (statusBarStyle == RNSStatusBarStyleLight) {
+    return UIStatusBarStyleLightContent;
+  }
+  return UIStatusBarStyleDefault;
+}
+#endif
+
+#if !TARGET_OS_TV
++ (UIInterfaceOrientation)defaultOrientationForOrientationMask:(UIInterfaceOrientationMask)orientationMask
+{
+  if (UIInterfaceOrientationMaskPortrait & orientationMask) {
+    return UIInterfaceOrientationPortrait;
+  } else if (UIInterfaceOrientationMaskLandscapeLeft & orientationMask) {
+    return UIInterfaceOrientationLandscapeLeft;
+  } else if (UIInterfaceOrientationMaskLandscapeRight & orientationMask) {
+    return UIInterfaceOrientationLandscapeRight;
+  } else if (UIInterfaceOrientationMaskPortraitUpsideDown & orientationMask) {
+    return UIInterfaceOrientationPortraitUpsideDown;
+  }
+  return UIInterfaceOrientationUnknown;
+}
+
++ (UIInterfaceOrientation)interfaceOrientationFromDeviceOrientation:(UIDeviceOrientation)deviceOrientation
+{
+  switch (deviceOrientation) {
+    case UIDeviceOrientationPortrait:
+      return UIInterfaceOrientationPortrait;
+    case UIDeviceOrientationPortraitUpsideDown:
+      return UIInterfaceOrientationPortraitUpsideDown;
+    // UIDevice and UIInterface landscape orientations are switched
+    case UIDeviceOrientationLandscapeLeft:
+      return UIInterfaceOrientationLandscapeRight;
+    case UIDeviceOrientationLandscapeRight:
+      return UIInterfaceOrientationLandscapeLeft;
+    default:
+      return UIInterfaceOrientationUnknown;
+  }
+}
+
++ (UIInterfaceOrientationMask)maskFromOrientation:(UIInterfaceOrientation)orientation
+{
+  return 1 << orientation;
+}
+#endif
+
++ (void)enforceDesiredDeviceOrientation
+{
+#if !TARGET_OS_TV
+  dispatch_async(dispatch_get_main_queue(), ^{
+    UIInterfaceOrientationMask orientationMask = UIInterfaceOrientationMaskAllButUpsideDown;
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+    if (@available(iOS 13, *)) {
+      UIWindow *firstWindow = [[[UIApplication sharedApplication] windows] firstObject];
+      if (firstWindow != nil) {
+        orientationMask = [firstWindow rootViewController].supportedInterfaceOrientations;
+      }
+    } else
+#endif
+    {
+      orientationMask = UIApplication.sharedApplication.keyWindow.rootViewController.supportedInterfaceOrientations;
+    }
+    UIInterfaceOrientation currentDeviceOrientation =
+        [RNSScreenWindowTraits interfaceOrientationFromDeviceOrientation:[[UIDevice currentDevice] orientation]];
+    UIInterfaceOrientation currentInterfaceOrientation = [RNSScreenWindowTraits interfaceOrientation];
+    UIInterfaceOrientation newOrientation = UIInterfaceOrientationUnknown;
+    if ([RNSScreenWindowTraits maskFromOrientation:currentDeviceOrientation] & orientationMask) {
+      if (!([RNSScreenWindowTraits maskFromOrientation:currentInterfaceOrientation] & orientationMask)) {
+        // if the device orientation is in the mask, but interface orientation is not, we rotate to device's orientation
+        newOrientation = currentDeviceOrientation;
+      } else {
+        if (currentDeviceOrientation != currentInterfaceOrientation) {
+          // if both device orientation and interface orientation are in the mask, but in different orientations, we
+          // rotate to device's orientation
+          newOrientation = currentDeviceOrientation;
+        }
+      }
+    } else {
+      if (!([RNSScreenWindowTraits maskFromOrientation:currentInterfaceOrientation] & orientationMask)) {
+        // if both device orientation and interface orientation are not in the mask, we rotate to closest available
+        // rotation from mask
+        newOrientation = [RNSScreenWindowTraits defaultOrientationForOrientationMask:orientationMask];
+      } else {
+        // if the device orientation is not in the mask, but interface orientation is in the mask, do nothing
+      }
+    }
+    if (newOrientation != UIInterfaceOrientationUnknown) {
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0
+      if (@available(iOS 16.0, *)) {
+        NSArray *array = [[[UIApplication sharedApplication] connectedScenes] allObjects];
+        UIWindowScene *scene = (UIWindowScene *)array[0];
+        UIWindowSceneGeometryPreferencesIOS *geometryPreferences =
+            [[UIWindowSceneGeometryPreferencesIOS alloc] initWithInterfaceOrientations:orientationMask];
+        [scene requestGeometryUpdateWithPreferences:geometryPreferences
+                                       errorHandler:^(NSError *_Nonnull error){
+                                       }];
+
+        // `attemptRotationToDeviceOrientation` is deprecated for modern OS versions
+        // so we need to use `setNeedsUpdateOfSupportedInterfaceOrientations`
+        UIViewController *topController = [UIApplication sharedApplication].keyWindow.rootViewController;
+        while (topController.presentedViewController) {
+          topController = topController.presentedViewController;
+        }
+
+        [topController setNeedsUpdateOfSupportedInterfaceOrientations];
+      } else
+#endif // Check for iOS 16
+      {
+        [[UIDevice currentDevice] setValue:@(newOrientation) forKey:@"orientation"];
+        [UIViewController attemptRotationToDeviceOrientation];
+      }
+    }
+  });
+#endif // !TARGET_TV_OS
+}
+
++ (void)updateWindowTraits
+{
+  [RNSScreenWindowTraits updateStatusBarAppearance];
+  [RNSScreenWindowTraits enforceDesiredDeviceOrientation];
+  [RNSScreenWindowTraits updateHomeIndicatorAutoHidden];
+}
+
+#if !TARGET_OS_TV
+// based on
+// https://stackoverflow.com/questions/57965701/statusbarorientation-was-deprecated-in-ios-13-0-when-attempting-to-get-app-ori/61249908#61249908
++ (UIInterfaceOrientation)interfaceOrientation
+{
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_0
+  if (@available(iOS 13.0, *)) {
+    UIWindow *firstWindow = [[[UIApplication sharedApplication] windows] firstObject];
+    if (firstWindow == nil) {
+      return UIInterfaceOrientationUnknown;
+    }
+    UIWindowScene *windowScene = firstWindow.windowScene;
+    if (windowScene == nil) {
+      return UIInterfaceOrientationUnknown;
+    }
+    return windowScene.interfaceOrientation;
+  } else
+#endif
+  {
+    return UIApplication.sharedApplication.statusBarOrientation;
+  }
+}
+#endif
+
+// method to be used in Expo for checking if RNScreens have trait set
++ (BOOL)shouldAskScreensForTrait:(RNSWindowTrait)trait
+                 includingModals:(BOOL)includingModals
+                inViewController:(UIViewController *)vc
+{
+  UIViewController *lastViewController = [[vc childViewControllers] lastObject];
+  if ([lastViewController conformsToProtocol:@protocol(RNSViewControllerDelegate)]) {
+    UIViewController *vc = nil;
+    if ([lastViewController isKindOfClass:[RNSViewController class]]) {
+      vc = [(RNSViewController *)lastViewController findActiveChildVC];
+    } else if ([lastViewController isKindOfClass:[RNSNavigationController class]]) {
+      vc = [(RNSNavigationController *)lastViewController topViewController];
+    }
+    return [vc isKindOfClass:[RNSScreen class]] &&
+        [(RNSScreen *)vc findChildVCForConfigAndTrait:trait includingModals:includingModals] != nil;
+  }
+  return NO;
+}
+
+// same method as above, but directly for orientation
++ (BOOL)shouldAskScreensForScreenOrientationInViewController:(UIViewController *)vc
+{
+  return [RNSScreenWindowTraits shouldAskScreensForTrait:RNSWindowTraitOrientation
+                                         includingModals:YES
+                                        inViewController:vc];
+}
+
+@end

package/ios/RNSSearchBar.h

@@ -0,0 +1,43 @@
+#import <UIKit/UIKit.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
+#endif
+
+#import <React/RCTBridge.h>
+#import <React/RCTComponent.h>
+#import <React/RCTViewManager.h>
+#import "RNSEnums.h"
+
+@interface RNSSearchBar :
+#ifdef RCT_NEW_ARCH_ENABLED
+    RCTViewComponentView <UISearchBarDelegate, RCTRNSSearchBarViewProtocol>
+#else
+    UIView <UISearchBarDelegate>
+#endif
+
+@property (nonatomic) BOOL hideWhenScrolling;
+@property (nonatomic) RNSSearchBarPlacement placement;
+@property (nonatomic, retain) UISearchController *controller;
+
+#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_16_0) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_16_0 && !TARGET_OS_TV
+- (UINavigationItemSearchBarPlacement)placementAsUINavigationItemSearchBarPlacement API_AVAILABLE(ios(16.0))
+    API_UNAVAILABLE(tvos, watchos);
+#endif // Check for iOS >= 16 && !TARGET_OS_TV
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#else
+@property (nonatomic, copy) RCTBubblingEventBlock onChangeText;
+@property (nonatomic, copy) RCTBubblingEventBlock onCancelButtonPress;
+@property (nonatomic, copy) RCTBubblingEventBlock onSearchButtonPress;
+@property (nonatomic, copy) RCTBubblingEventBlock onFocus;
+@property (nonatomic, copy) RCTBubblingEventBlock onBlur;
+#endif
+
+@end
+
+@interface RNSSearchBarManager : RCTViewManager
+
+@end