@apexnative/navigation 1.0.0-alpha.0 → 1.0.0-alpha.10

package/ios/Layouts/Root/ANNSplashViewController.mm

@@ -34,9 +34,63 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     return names;
 }
 
+static NSDictionary *ANNDictionaryOrNil(id value) {
+    return [value isKindOfClass:NSDictionary.class] ? value : nil;
+}
+
+static NSString *ANNStringOrNil(id value) {
+    return [value isKindOfClass:NSString.class] && [value length] > 0 ? value : nil;
+}
+
+// The definition that a plural key (`UILaunchScreens`, `UILaunchStoryboards`) marks as its default.
+static NSDictionary *ANNDefaultDefinition(id plural, NSString *definitionsKey,
+                                          NSString *identifierKey, NSString *defaultKey) {
+    NSDictionary *dictionary = ANNDictionaryOrNil(plural);
+    NSArray *definitions = dictionary[definitionsKey];
+    NSString *defaultIdentifier = ANNStringOrNil(dictionary[defaultKey]);
+    if (![definitions isKindOfClass:NSArray.class] || !defaultIdentifier) {
+        return nil;
+    }
+    for (id definition in definitions) {
+        NSDictionary *entry = ANNDictionaryOrNil(definition);
+        if ([entry[identifierKey] isEqual:defaultIdentifier]) {
+            return entry;
+        }
+    }
+    return nil;
+}
+
+// The launch screen that iOS builds from the Info.plist without a storyboard, or nil when it shows a storyboard. Of
+// `UILaunchStoryboardName`, `UILaunchScreen`, the default of `UILaunchStoryboards` and the default of
+// `UILaunchScreens`, the last one present wins (SplashBoard's `XBApplicationLaunchCompatibilityInfo`). A launch by a
+// link that `UILaunchScreens` maps to a screen of its own still gets the default here.
+static NSDictionary *ANNLaunchScreenConfiguration(NSBundle *bundle) {
+    NSDictionary *screen =
+        ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchScreens"],
+                             @"UILaunchScreenDefinitions", @"UILaunchScreenIdentifier",
+                             @"UIDefaultLaunchScreen");
+    if (screen) {
+        return screen;
+    }
+    if (ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchStoryboards"],
+                             @"UILaunchStoryboardDefinitions", @"UILaunchStoryboardIdentifier",
+                             @"UIDefaultLaunchStoryboard")) {
+        return nil;
+    }
+    return ANNDictionaryOrNil([bundle objectForInfoDictionaryKey:@"UILaunchScreen"]);
+}
+
 @implementation ANNSplashViewController {
     UIViewController *_content;
     UIView *_contentView;
+    NSDictionary *_launchScreen;
+    // The parts of a launch screen built from `UILaunchScreen`, laid out once the safe area is known.
+    UIImageView *_imageView;
+    BOOL _imageRespectsSafeArea;
+    UINavigationBar *_navigationBar;
+    UIImageView *_navigationBarImageView;
+    UIView *_bottomBar;
+    UIImageView *_bottomBarImageView;
 }
 
 - (instancetype)initWithContent:(UIViewController *)content
@@ -52,6 +106,12 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
 
 + (instancetype)launchScreenCopyWithBounds:(CGRect)bounds {
     NSBundle *bundle = NSBundle.mainBundle;
+    NSDictionary *launchScreen = ANNLaunchScreenConfiguration(bundle);
+    if (launchScreen) {
+        ANNSplashViewController *copy = [[self alloc] initWithContent:nil contentView:nil blank:NO];
+        copy->_launchScreen = launchScreen;
+        return copy;
+    }
     NSString *storyboardName = [bundle objectForInfoDictionaryKey:@"UILaunchStoryboardName"];
     if ([storyboardName isKindOfClass:NSString.class] && storyboardName.length > 0) {
         UIViewController *initial = nil;
@@ -97,6 +157,10 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
         view.backgroundColor = windowHasColor ? UIColor.clearColor : UIColor.systemBackgroundColor;
         return;
     }
+    if (_launchScreen) {
+        [self buildLaunchScreen];
+        return;
+    }
     UIView *contentView = _contentView;
     if (_content) {
         [self addChildViewController:_content];
@@ -109,6 +173,89 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     [_content didMoveToParentViewController:self];
 }
 
+#pragma mark - The launch screen of `UILaunchScreen`
+
+// Built as SplashBoard builds it: the named color over the whole screen, else the system background; the named image
+// at its own size in the middle of the screen or of its safe area, stretched instead when the asset has slicing; a tab
+// bar or a toolbar at the bottom and a navigation bar at the top, the system's own bars, or the bar's named image
+// stretched over the bar's place. A name the asset catalog doesn't have leaves its part out, as iOS does.
+- (void)buildLaunchScreen {
+    UIView *view = self.view;
+    NSString *colorName = ANNStringOrNil(_launchScreen[@"UIColorName"]);
+    UIColor *color = colorName ? [UIColor colorNamed:colorName] : nil;
+    view.backgroundColor = color ?: UIColor.systemBackgroundColor;
+
+    NSString *imageName = ANNStringOrNil(_launchScreen[@"UIImageName"]);
+    UIImage *image = imageName ? [UIImage imageNamed:imageName] : nil;
+    if (image) {
+        _imageView = [[UIImageView alloc] initWithImage:image];
+        _imageView.contentMode = UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero)
+                                     ? UIViewContentModeCenter
+                                     : UIViewContentModeScaleToFill;
+        id respects = _launchScreen[@"UIImageRespectsSafeAreaInsets"];
+        _imageRespectsSafeArea = [respects respondsToSelector:@selector(boolValue)] &&
+                                 [respects boolValue];
+        [view addSubview:_imageView];
+    }
+
+    // A toolbar takes the bottom before a tab bar; a navigation bar comes on top of either.
+    id toolbar = _launchScreen[@"UIToolbar"];
+    id tabBar = _launchScreen[@"UITabBar"];
+    if (toolbar || tabBar) {
+        _bottomBar = toolbar ? [UIToolbar new] : [UITabBar new];
+        _bottomBarImageView = [self addBar:_bottomBar configuration:toolbar ?: tabBar];
+    }
+    id navigationBar = _launchScreen[@"UINavigationBar"];
+    if (navigationBar) {
+        _navigationBar = [UINavigationBar new];
+        _navigationBarImageView = [self addBar:_navigationBar configuration:navigationBar];
+    }
+}
+
+// Adds the bar, or its image in its place when its configuration names one that loads.
+- (UIImageView *)addBar:(UIView *)bar configuration:(id)configuration {
+    NSString *name = ANNStringOrNil(ANNDictionaryOrNil(configuration)[@"UIImageName"]);
+    UIImage *image = name ? [UIImage imageNamed:name] : nil;
+    UIImageView *imageView = image ? [[UIImageView alloc] initWithImage:image] : nil;
+    bar.hidden = imageView != nil;
+    [self.view addSubview:bar];
+    if (imageView) {
+        [self.view addSubview:imageView];
+    }
+    return imageView;
+}
+
+// The safe area is known only in the window, so the parts are laid out here, after every change of it.
+- (void)viewDidLayoutSubviews {
+    [super viewDidLayoutSubviews];
+    if (!_launchScreen) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    _imageView.frame =
+        _imageRespectsSafeArea ? UIEdgeInsetsInsetRect(bounds, safeArea) : bounds;
+    [self layOutBar:_bottomBar imageView:_bottomBarImageView atBottom:YES];
+    [self layOutBar:_navigationBar imageView:_navigationBarImageView atBottom:NO];
+}
+
+// A bar is as tall as UIKit makes it, plus the safe area on its edge of the screen, and as wide as the screen.
+- (void)layOutBar:(UIView *)bar
+        imageView:(UIImageView *)imageView
+         atBottom:(BOOL)atBottom {
+    if (!bar) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    CGFloat height = [bar sizeThatFits:bounds.size].height +
+                     (atBottom ? safeArea.bottom : safeArea.top);
+    CGFloat y = atBottom ? CGRectGetMaxY(bounds) - height : CGRectGetMinY(bounds);
+    CGRect frame = CGRectMake(CGRectGetMinX(bounds), y, CGRectGetWidth(bounds), height);
+    bar.frame = frame;
+    imageView.frame = frame;
+}
+
 #pragma mark - The status bar, as the launch screen had it
 
 - (UIStatusBarStyle)preferredStatusBarStyle {

package/ios/Layouts/Screen/ANNComponentPresenter.h

@@ -19,11 +19,19 @@ NS_ASSUME_NONNULL_BEGIN
 /// it. Nothing before the screen's view is loaded.
 - (void)applyBackground:(ANNNavigationOptions *)resolvedOptions;
 
-/// `statusBar.blur` (iOS): UIKit's regular blur over the screen's own view in the frame of the scene's status bar at
-/// this moment (x 0, the view's width; it doesn't follow a rotation); `false` or none removes it. At each appearance
-/// and at a merge that names it; nothing before the screen's view is loaded.
+/// `statusBar.blur` (iOS): UIKit's regular blur over the screen's own view in the frame of the scene's status bar (x 0,
+/// the view's width), laid out at once; `false` or none removes it. At each appearance and at a merge that names it;
+/// nothing before the screen's view is loaded.
 - (void)applyStatusBarBlur:(ANNNavigationOptions *)resolvedOptions;
 
+/// The blur takes the status bar's frame as it is now; nothing without a blur. The single place of its frame: the blur
+/// as it is applied, the screen's view laid out (a rotation, a new window size, a new safe area), a size transition
+/// along its animation and at its end, the turn after new traits, and `statusBarDidChange`.
+- (void)layOutStatusBarBlur;
+
+/// The status bar was asked again (hidden or shown, a new style): every blur takes its frame.
++ (void)statusBarDidChange;
+
 /// The blur stays the last subview of the screen's view: the content added after it goes under it.
 - (void)keepStatusBarBlurOnTop;
 

package/ios/Layouts/Screen/ANNComponentPresenter.mm

@@ -5,6 +5,10 @@
 #import "ANNTopBarPresenter.h"
 #import "ANNUtils.h"
 
+// The presenters whose screen shows `statusBar.blur`: the status bar hidden or shown lays out no view, so they hear of
+// it from the system UI (`statusBarDidChange`).
+static NSHashTable<ANNComponentPresenter *> *ANNBlurringPresenters;
+
 @implementation ANNComponentPresenter {
     // `statusBar.blur` while it is on.
     UIVisualEffectView *_statusBarBlur;
@@ -95,9 +99,7 @@
 
 #pragma mark - The status bar's blur (`statusBar.blur`)
 
-// Over the screen's own view, never over a React view; no touches, nothing for VoiceOver. The frame is the scene's
-// status bar's as it is now, in the view's own coordinates without a conversion: a pushed screen's view may still be
-// out of place while it appears.
+// Over the screen's own view, never over a React view; no touches, nothing for VoiceOver.
 - (void)applyStatusBarBlur:(ANNNavigationOptions *)resolvedOptions {
     ANNComponentViewController *screen = self.screen;
     if (!screen.isViewLoaded) {
@@ -106,6 +108,7 @@
     if (![resolvedOptions.statusBar.blur withDefault:NO]) {
         [_statusBarBlur removeFromSuperview];
         _statusBarBlur = nil;
+        [ANNBlurringPresenters removeObject:self];
         return;
     }
     UIView *view = screen.view;
@@ -115,15 +118,40 @@
         _statusBarBlur.userInteractionEnabled = NO;
         _statusBarBlur.isAccessibilityElement = NO;
         _statusBarBlur.accessibilityElementsHidden = YES;
+        if (!ANNBlurringPresenters) {
+            ANNBlurringPresenters = [NSHashTable weakObjectsHashTable];
+        }
+        [ANNBlurringPresenters addObject:self];
     }
-    CGRect statusBar = ANNUtils.statusBarFrame;
-    _statusBarBlur.frame = CGRectMake(0, CGRectGetMinY(statusBar), CGRectGetWidth(view.bounds),
-                                      CGRectGetHeight(statusBar));
     if (_statusBarBlur.superview != view) {
         [view addSubview:_statusBarBlur];
     } else {
         [view bringSubviewToFront:_statusBarBlur];
     }
+    [self layOutStatusBarBlur];
+}
+
+// The status bar's frame in the scene of the screen's window (the main window's before the screen is in one), in the
+// view's own coordinates without a conversion: a pushed screen's view may still be out of place while it appears. A
+// hidden status bar has no frame, and the blur no height.
+- (void)layOutStatusBarBlur {
+    UIView *view = _statusBarBlur.superview;
+    if (!view) {
+        return;
+    }
+    UIWindowScene *scene = view.window.windowScene;
+    CGRect statusBar = scene ? scene.statusBarManager.statusBarFrame : ANNUtils.statusBarFrame;
+    CGRect frame = CGRectMake(0, CGRectGetMinY(statusBar), CGRectGetWidth(view.bounds),
+                              CGRectGetHeight(statusBar));
+    if (!CGRectEqualToRect(_statusBarBlur.frame, frame)) {
+        _statusBarBlur.frame = frame;
+    }
+}
+
++ (void)statusBarDidChange {
+    for (ANNComponentPresenter *presenter in ANNBlurringPresenters.allObjects) {
+        [presenter layOutStatusBarBlur];
+    }
 }
 
 - (void)keepStatusBarBlurOnTop {

package/ios/Layouts/Screen/ANNComponentViewController.h

@@ -1,6 +1,7 @@
 #import "ANNArrangementScreenDelegate.h"
 #import "ANNLayoutProtocol.h"
 #import "ANNScreenAppearance.h"
+#import "ANNScreenPlace.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <UIKit/UIKit.h>
 
@@ -10,8 +11,8 @@ NS_ASSUME_NONNULL_BEGIN
 ///
 /// Its view has the size of the screen of the navigation window's scene; the content sits in the root frame, by the one
 /// "under bars" rule (`ANNScreenBars`). Every recompute of the frame (a layout, a change of the safe area or the
-/// traits, `mergeOptions`, an appearance) gives the modules the screen's insets, padding and regions
-/// (`ANNScreenInsets`, `ANNScreenRegions`). Its presenter is an `ANNComponentPresenter`.
+/// traits, `mergeOptions`, an appearance) gives the store the screen's insets, padding and regions
+/// (`ANNScreenEnvironment`). Its presenter is an `ANNComponentPresenter`.
 ///
 /// The screen answers UIKit's questions about the system UI (native screens too): the status bar's style and visibility
 /// (never animated), the orientations, the home indicator, the deferred edges and the vertical bars, from its resolved
@@ -42,21 +43,22 @@ NS_ASSUME_NONNULL_BEGIN
 /// nobody rendered gets its content when UIKit first loads its view.
 - (void)render;
 
+/// Where the screen will show while it waits for its content out of it (parked by a stack's or `showInColumn`'s wait,
+/// or in a tab rendered before it shows, `ANNParking`): it lays out with that place's safe area and bars
+/// (`ANNScreenPlace`), as it will once it shows there. Asked at each layout, and kept past the parking until UIKit
+/// gives the screen a safe area of its own in a parent (the push lays it out once before that, with none), or as it
+/// appears. Nil: its view's own. Set by the one that parks the screen.
+@property(nonatomic, copy, nullable) ANNScreenPlace *_Nullable (^placeWhileParked)(void);
+
+/// The place is kept until the screen appears, not only until UIKit gives it a safe area: a tab's screen rendered
+/// before the tab shows gets a part of it first (the bar without the status bar) as UIKit lays the tab out. Set with
+/// `placeWhileParked`, and goes with it.
+@property(nonatomic) BOOL placeKeptUntilAppearance;
+
 /// Applies the "under bars" rule to the root frame again, then gives the modules the insets, the padding and the
 /// regions of the screen. Nothing before the view loaded; the safe area only in a window.
 - (void)updateRootLayout;
 
-/// The content view (only the core's React view, never the screen's own view) mounts unseen in `host` (the tabs'
-/// preload window) at the frame it has, while the screen's tab isn't shown. NO when there is nothing to lend: no React
-/// view of its own, in a window already, lent already, or the screen went.
-- (BOOL)lendContentTo:(UIView *)host;
-
-/// The lent content comes back into the screen's view at its root frame; also as the screen first appears.
-- (void)takeContentBack;
-
-/// The content is lent (`lendContentTo:`): `updateRootLayout` leaves its frame alone meanwhile.
-@property(nonatomic, readonly) BOOL contentIsLent;
-
 /// The transition that removes the screen starts (before its destroy): with `blurOnUnmount` in its resolved options,
 /// the editing inside its view ends and the keyboard goes (`blurOnUnmount`).
 - (void)screenWillLeave;