react-native-screens 4.12.0 → 4.13.0

package/ios/bottom-tabs/RNSTabBarController.mm

@@ -0,0 +1,206 @@
+#import "RNSTabBarController.h"
+#import <React/RCTAssert.h>
+#import <React/RCTLog.h>
+
+@implementation RNSTabBarController {
+  NSArray<RNSTabsScreenViewController *> *_Nullable _tabScreenControllers;
+
+#if !RCT_NEW_ARCH_ENABLED
+  BOOL _isControllerFlushBlockScheduled;
+#endif // !RCT_NEW_ARCH_ENABLED
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _tabScreenControllers = nil;
+    _tabBarAppearanceCoordinator = [RNSTabBarAppearanceCoordinator new];
+    _tabsHostComponentView = nil;
+
+#if !RCT_NEW_ARCH_ENABLED
+    _isControllerFlushBlockScheduled = NO;
+#endif // !RCT_NEW_ARCH_ENABLED
+  }
+  return self;
+}
+
+- (instancetype)initWithTabsHostComponentView:(nullable RNSBottomTabsHostComponentView *)tabsHostComponentView
+{
+  if (self = [self init]) {
+    _tabsHostComponentView = tabsHostComponentView;
+  }
+  return self;
+}
+
+- (void)tabBar:(UITabBar *)tabBar didSelectItem:(UITabBarItem *)item
+{
+  NSLog(@"TabBar: %@ didSelectItem: %@", tabBar, item);
+}
+
+#pragma mark-- Signals
+
+- (void)childViewControllersHaveChangedTo:(NSArray<RNSTabsScreenViewController *> *)reactChildControllers
+{
+  _tabScreenControllers = reactChildControllers;
+  self.needsUpdateOfReactChildrenControllers = true;
+}
+
+- (void)setNeedsUpdateOfReactChildrenControllers:(bool)needsReactChildrenUpdate
+{
+  _needsUpdateOfReactChildrenControllers = true;
+  self.needsUpdateOfSelectedTab = true;
+#if !RCT_NEW_ARCH_ENABLED
+  [self scheduleControllerUpdateIfNeeded];
+#endif // !RCT_NEW_ARCH_ENABLED
+}
+
+- (void)setNeedsUpdateOfSelectedTab:(bool)needsSelectedTabUpdate
+{
+  _needsUpdateOfSelectedTab = needsSelectedTabUpdate;
+#if !RCT_NEW_ARCH_ENABLED
+  [self scheduleControllerUpdateIfNeeded];
+#endif // !RCT_NEW_ARCH_ENABLED
+}
+
+- (void)setNeedsUpdateOfTabBarAppearance:(bool)needsUpdateOfTabBarAppearance
+{
+  _needsUpdateOfTabBarAppearance = needsUpdateOfTabBarAppearance;
+#if !RCT_NEW_ARCH_ENABLED
+  [self scheduleControllerUpdateIfNeeded];
+#endif // !RCT_NEW_ARCH_ENABLED
+}
+
+#pragma mark-- RNSReactTransactionObserving
+
+- (void)reactMountingTransactionWillMount
+{
+  NSLog(@"TabBarCtrl mountintTransactionWillMount");
+}
+
+- (void)reactMountingTransactionDidMount
+{
+  NSLog(@"TabBarCtrl mountintTransactionDidMount running updates");
+  [self updateReactChildrenControllersIfNeeded];
+  [self updateSelectedViewControllerIfNeeded];
+  [self updateTabBarAppearanceIfNeeded];
+}
+
+#pragma mark-- Signals related
+
+- (void)updateReactChildrenControllersIfNeeded
+{
+  if (_needsUpdateOfReactChildrenControllers) {
+    [self updateReactChildrenControllers];
+  }
+}
+
+- (void)updateReactChildrenControllers
+{
+  NSLog(@"TabBarCtrl updateReactChildrenControllers");
+  _needsUpdateOfReactChildrenControllers = false;
+
+  if (_tabScreenControllers == nil) {
+    RCTLogWarn(@"[RNScreens] Attempt to update react children while the _updatedChildren array is nil!");
+    return;
+  }
+
+  [self setViewControllers:_tabScreenControllers animated:[[self viewControllers] count] != 0];
+}
+
+- (void)updateSelectedViewControllerIfNeeded
+{
+  if (_needsUpdateOfSelectedTab) {
+    [self updateSelectedViewController];
+  }
+}
+
+- (void)updateSelectedViewController
+{
+  NSLog(@"TabBarCtrl updateSelectedViewController");
+  _needsUpdateOfSelectedTab = false;
+
+#if !defined(NDEBUG)
+  [self assertExactlyOneFocusedTab];
+#endif
+
+  RNSTabsScreenViewController *_Nullable selectedViewController = nil;
+  for (RNSTabsScreenViewController *tabViewController in self.viewControllers) {
+    NSLog(
+        @"Update Selected View Controller [%ld] isFocused %d",
+        tabViewController.tabScreenComponentView.tag,
+        tabViewController.tabScreenComponentView.isSelectedScreen);
+    if (tabViewController.tabScreenComponentView.isSelectedScreen == true) {
+      selectedViewController = tabViewController;
+      break;
+    }
+  }
+
+  RCTAssert(selectedViewController != nil, @"[RNScreens] No selected view controller!");
+
+  NSLog(@"Change selected view controller to: %@", selectedViewController);
+
+  [selectedViewController.tabScreenComponentView overrideScrollViewBehaviorInFirstDescendantChainIfNeeded];
+  [self setSelectedViewController:selectedViewController];
+}
+
+- (void)updateTabBarAppearanceIfNeeded
+{
+  if (_needsUpdateOfTabBarAppearance) {
+    [self updateTabBarAppearance];
+  }
+}
+
+- (void)updateTabBarAppearance
+{
+  NSLog(@"TabBarCtrl updateTabBarAppearance");
+  _needsUpdateOfTabBarAppearance = false;
+
+  [_tabBarAppearanceCoordinator updateAppearanceOfTabBar:[self tabBar]
+                                   withHostComponentView:self.tabsHostComponentView
+                                    tabScreenControllers:_tabScreenControllers
+                                             imageLoader:[self.tabsHostComponentView reactImageLoader]];
+}
+
+#if !defined(NDEBUG)
+- (void)assertExactlyOneFocusedTab
+{
+  int selectedCount = 0;
+  for (RNSTabsScreenViewController *tabViewController in _tabScreenControllers) {
+    if (tabViewController.tabScreenComponentView.isSelectedScreen) {
+      ++selectedCount;
+    }
+  }
+  RCTAssert(
+      selectedCount == 1, @"[RNScreens] Invariant violation. Expected exactly 1 focused tab, got: %d", selectedCount);
+}
+#endif
+
+#if !RCT_NEW_ARCH_ENABLED
+
+#pragma mark - LEGACY Paper scheduling methods
+
+// TODO: These could be moved to separate scheduler class
+
+- (void)scheduleControllerUpdateIfNeeded
+{
+  if (_isControllerFlushBlockScheduled) {
+    return;
+  }
+
+  _isControllerFlushBlockScheduled = YES;
+
+  auto *__weak weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    auto *strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    strongSelf->_isControllerFlushBlockScheduled = NO;
+    [strongSelf reactMountingTransactionWillMount];
+    [strongSelf reactMountingTransactionDidMount];
+  });
+}
+
+#endif // !RCT_NEW_ARCH_ENABLED
+
+@end

package/ios/bottom-tabs/RNSTabBarControllerDelegate.h

@@ -0,0 +1,9 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSTabBarControllerDelegate : NSObject <UITabBarControllerDelegate>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSTabBarControllerDelegate.mm

@@ -0,0 +1,63 @@
+#import "RNSTabBarControllerDelegate.h"
+#import <React/RCTAssert.h>
+#import "RNSTabBarController.h"
+#import "RNSTabsScreenViewController.h"
+
+@implementation RNSTabBarControllerDelegate
+
+- (BOOL)tabBarController:(UITabBarController *)tabBarController
+    shouldSelectViewController:(UIViewController *)viewController
+{
+  // TODO: This will crash with "More" view controller.
+  RCTAssert(
+      [tabBarController isKindOfClass:RNSTabBarController.class],
+      @"[RNScreens] Unexpected type of controller: %@",
+      tabBarController.class);
+  RCTAssert(
+      [viewController isKindOfClass:RNSTabsScreenViewController.class],
+      @"[RNScreens] Unexpected type of controller: %@",
+      viewController.class);
+
+  RNSTabBarController *tabBarCtrl = static_cast<RNSTabBarController *>(tabBarController);
+  RNSTabsScreenViewController *tabScreenCtrl = static_cast<RNSTabsScreenViewController *>(viewController);
+
+  bool repeatedSelectionHandledNatively = false;
+
+  // Detect repeated selection and inform tabScreenController
+  if ([tabBarCtrl selectedViewController] == tabScreenCtrl) {
+    repeatedSelectionHandledNatively = [tabScreenCtrl tabScreenSelectedRepeatedly];
+  }
+
+  // TODO: send an event with information about event being handled natively
+  if (!repeatedSelectionHandledNatively) {
+    [tabBarCtrl.tabsHostComponentView
+        emitOnNativeFocusChangeRequestSelectedTabScreen:tabScreenCtrl.tabScreenComponentView];
+      
+    // TODO: handle overrideScrollViewBehaviorInFirstDescendantChainIfNeeded for natively-driven tabs
+    return ![self shouldPreventNativeTabChangeWithinTabBarController:tabBarCtrl];
+  }
+
+  // As we're selecting the same controller, returning both true and false works here.
+  return true;
+}
+
+- (void)tabBarController:(UITabBarController *)tabBarController
+    didSelectViewController:(UIViewController *)viewController
+{
+  RCTAssert(
+      [tabBarController isKindOfClass:RNSTabBarController.class],
+      @"[RNScreens] Unexpected type of controller: %@",
+      tabBarController.class);
+  RCTAssert(
+      [viewController isKindOfClass:RNSTabsScreenViewController.class],
+      @"[RNScreens] Unexpected type of controller: %@",
+      viewController.class);
+}
+
+- (bool)shouldPreventNativeTabChangeWithinTabBarController:(nonnull RNSTabBarController *)tabBarCtrl
+{
+  // This handles the tabsHostComponentView nullability
+  return [tabBarCtrl.tabsHostComponentView experimental_controlNavigationStateInJS] ?: NO;
+}
+
+@end

package/ios/bottom-tabs/RNSTabsScreenViewController.h

@@ -0,0 +1,42 @@
+#import <UIKit/UIKit.h>
+#import "RNSBottomTabsScreenComponentView.h"
+#import "RNSBottomTabsSpecialEffectsSupporting.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSTabsScreenViewController : UIViewController
+
+@property (nonatomic, strong, readonly, nullable) RNSBottomTabsScreenComponentView *tabScreenComponentView;
+@property (nonatomic, weak, readonly, nullable) id<RNSBottomTabsSpecialEffectsSupporting> tabsSpecialEffectsDelegate;
+
+/**
+ * Tell the controller that the tab screen it owns has got its react-props-focus changed.
+ */
+- (void)tabScreenFocusHasChanged;
+
+/**
+ * Tell the controller that the tab screen it owns has got its react-props related to appearance changed.
+ */
+- (void)tabItemAppearanceHasChanged;
+
+/**
+ * Tell the controller that the tab item related to this controller has been selected again after being presented.
+ * Returns boolean indicating whether the action has been handled.
+ */
+- (bool)tabScreenSelectedRepeatedly;
+
+/**
+ * Set new special effects delegate.
+ */
+- (void)setTabsSpecialEffectsDelegate:(nonnull id<RNSBottomTabsSpecialEffectsSupporting>)delegate;
+
+/**
+ * Inform the controller about resignation from being special effects delegate. If resignation comes from current
+ * tabsSpecialEffectsDelegate, this method sets tabsSpecialEffectsDelegate to nil. If tabsSpecialEffectsDelegate has
+ * already changed (to other delegate or nil), this method does nothing.
+ */
+- (void)clearTabsSpecialEffectsDelegateIfNeeded:(nonnull id<RNSBottomTabsSpecialEffectsSupporting>)delegate;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSTabsScreenViewController.mm

@@ -0,0 +1,105 @@
+#import "RNSTabsScreenViewController.h"
+#import "RNSScrollViewFinder.h"
+#import "RNSTabBarController.h"
+#import "UIScrollView+RNScreens.h"
+
+@implementation RNSTabsScreenViewController
+
+- (nullable RNSTabBarController *)findTabBarController
+{
+  return static_cast<RNSTabBarController *_Nullable>(self.tabBarController);
+}
+
+- (nullable RNSBottomTabsScreenComponentView *)tabScreenComponentView
+{
+  return static_cast<RNSBottomTabsScreenComponentView *>(self.view);
+}
+
+- (void)tabScreenFocusHasChanged
+{
+  NSLog(
+      @"TabScreen [%ld] changed focus: %d",
+      self.tabScreenComponentView.tag,
+      self.tabScreenComponentView.isSelectedScreen);
+
+  // The focus of owned tab has been updated from react. We tell the parent controller that it should update the
+  // container.
+  [[self findTabBarController] setNeedsUpdateOfSelectedTab:true];
+}
+
+- (void)tabItemAppearanceHasChanged
+{
+  [[self findTabBarController] setNeedsUpdateOfTabBarAppearance:true];
+}
+
+- (void)viewWillAppear:(BOOL)animated
+{
+  [self.tabScreenComponentView.reactEventEmitter emitOnWillAppear];
+}
+
+- (void)viewDidAppear:(BOOL)animated
+{
+  [self.tabScreenComponentView.reactEventEmitter emitOnDidAppear];
+}
+
+- (void)viewWillDisappear:(BOOL)animated
+{
+  [self.tabScreenComponentView.reactEventEmitter emitOnWillDisappear];
+}
+
+- (void)viewDidDisappear:(BOOL)animated
+{
+  [self.tabScreenComponentView.reactEventEmitter emitOnDidDisappear];
+}
+
+- (void)didMoveToParentViewController:(UIViewController *)parent
+{
+  NSLog(@"TabScreen [%ld] ctrl moved to parent: %@", self.tabScreenComponentView.tag, parent);
+
+  if (parent == nil) {
+    return;
+  }
+
+  RCTAssert(
+      [parent isKindOfClass:RNSTabBarController.class],
+      @"[RNScreens] TabScreenViewController added to parent of unexpected type: %@",
+      parent.class);
+
+  RNSTabBarController *tabBarCtrl = [self findTabBarController];
+
+  RCTAssert(
+      tabBarCtrl != nil, @"[RNScreens] nullish tabBarCtrl after TabScreenViewController has been added to parent");
+
+  [tabBarCtrl setNeedsUpdateOfTabBarAppearance:true];
+  [tabBarCtrl updateTabBarAppearanceIfNeeded];
+}
+
+- (void)setTabsSpecialEffectsDelegate:(id<RNSBottomTabsSpecialEffectsSupporting>)delegate
+{
+  RCTAssert(
+      delegate != nil,
+      @"[RNScreens] can't set special effects delegate to nil. Use clearTabsSpecialEffectsDelegateIfNeeded instead.");
+  _tabsSpecialEffectsDelegate = delegate;
+}
+
+- (void)clearTabsSpecialEffectsDelegateIfNeeded:(id<RNSBottomTabsSpecialEffectsSupporting>)delegate
+{
+  if (_tabsSpecialEffectsDelegate == delegate) {
+    _tabsSpecialEffectsDelegate = nil;
+  }
+}
+
+- (bool)tabScreenSelectedRepeatedly
+{
+  if ([self tabsSpecialEffectsDelegate] != nil) {
+    return [[self tabsSpecialEffectsDelegate] onRepeatedTabSelectionOfTabScreenController:self];
+  } else if (self.tabScreenComponentView.shouldUseRepeatedTabSelectionScrollToTopSpecialEffect) {
+    UIScrollView *scrollView =
+        [RNSScrollViewFinder findScrollViewInFirstDescendantChainFrom:[self tabScreenComponentView]];
+    return [scrollView rnscreens_scrollToTop];
+  }
+
+  return false;
+}
+
+@end

package/ios/bottom-tabs/extensions/RNSBottomTabsHostComponentView+RNSImageLoader.h

@@ -0,0 +1,21 @@
+#import "RNSBottomTabsHostComponentView.h"
+
+#if defined(__cplusplus) && RCT_NEW_ARCH_ENABLED
+#import "RNSBottomTabsShadowNode.h"
+#endif // defined(__cplusplus) && RCT_NEW_ARCH_ENABLED
+
+NS_ASSUME_NONNULL_BEGIN
+
+#if defined(__cplusplus) && RCT_NEW_ARCH_ENABLED
+
+@class RCTImageLoader;
+
+@interface RNSBottomTabsHostComponentView (RNSImageLoader)
+
+- (nullable RCTImageLoader *)retrieveImageLoaderFromState:(facebook::react::RNSBottomTabsShadowNode::ConcreteState::Shared)state;
+
+@end
+
+#endif // defined(__cplusplus) && RCT_NEW_ARCH_ENABLED
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/extensions/RNSBottomTabsHostComponentView+RNSImageLoader.mm

@@ -0,0 +1,22 @@
+#import "RNSBottomTabsHostComponentView+RNSImageLoader.h"
+
+#if RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTImageLoader.h>
+#import <react/utils/ManagedObjectWrapper.h>
+
+@implementation RNSBottomTabsHostComponentView (RNSImageLoader)
+
+- (nullable RCTImageLoader *)retrieveImageLoaderFromState:(facebook::react::RNSBottomTabsShadowNode::ConcreteState::Shared)receivedState
+{
+  if (auto imgLoaderPtr = receivedState.get()->getData().getImageLoader().lock()) {
+    return react::unwrapManagedObject(imgLoaderPtr);
+  }
+  
+  RCTLogWarn(@"[RNScreens] unable to retrieve RCTImageLoader");
+  return nil;
+}
+
+@end
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/bridging/RNSReactBaseView.h

@@ -0,0 +1,31 @@
+// Hide C++ symbols from C compiler used when building Swift module
+#if defined(__cplusplus)
+
+#pragma mark - New architecture definitions
+#if RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+
+@interface RNSReactBaseView : RCTViewComponentView
+@end
+
+#else
+#pragma mark - Legacy architecture definitions
+
+#import <React/RCTView.h>
+
+@interface RNSReactBaseView : RCTView
+@end
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+#else
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSReactBaseView : UIView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // __cplusplus

package/ios/bridging/RNSReactBaseView.mm

@@ -0,0 +1,5 @@
+#import "RNSReactBaseView.h"
+
+@implementation RNSReactBaseView
+
+@end

package/ios/bridging/Swift-Bridging.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#if __has_include(<RNScreens/RNScreens-Swift.h>)
+#import <RNScreens/RNScreens-Swift.h>
+#else
+#import "RNScreens-Swift.h"
+#endif