UINavigationController on Andrew Bancroft

Accessing the Root View Controller at Launch on iOS 13 with SceneDelegate

Fri, 07 Jun 2019 18:20:41 +0000

A new SceneDelegate was introduced for Storyboard-based apps in iOS 13, and with it came some changes in how you’re able to access your app’s root view controller at app launch.

The Old Way

AppDelegate Swift file used to be where code landed for accessing your app’s rootViewController:

1    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
2        // Override point for customization after application launch.
3        let rootVC = window?.rootViewController
4
5        return true
6    }

What To Do Now

Now, you’ll be moving that code over to your app’s SceneDelegate Swift file:

 1class SceneDelegate: UIResponder, UIWindowSceneDelegate {
 2
 3    var window: UIWindow?
 4
 5
 6    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
 7        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
 8        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
 9        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
10        guard let _ = (scene as? UIWindowScene) else { return }
11        
12        let rootVC = self.window?.rootViewController 
13    }
14
15    // ... the rest of SceneDelegate
16}

Adding Buttons to the Navigation Bar with Storyboards

Thu, 14 Apr 2016 18:20:41 +0000

Updated on March 20, 2017 – Xcode 8 & Swift 3

If you’re having trouble figuring out how to add buttons to the navigation bar in your Storyboard-based iOS app, my goal in this article is to help you through the process. Knowing what to click and where to drag to get things wired up isn’t entirely intuitive, so I want to be of help if I can.

Lots of StackOverflow posts point us to just adding the buttons in code, but for those who lean toward trying to do as much in the Storyboard designer as possible, this approach feels out of place.

The example I’m outlining here is done solely in the Storyboard.

Example scenario

The scenario is as follows:

We have a main screen with an add button in the top right of the navigation bar
Pressing Add will display a modal screen with two buttons in the navigation bar: Cancel, and Save

The Goal: Use only the Storyboard to add the ‘Add’ button, and the Cancel and Save buttons to the navigation bar. The end result will be something like this:

An example git repository has been created for this walk-through over at GitHub:

Resources

Storyboard Navigation Controller Example

Main Storyboard scene setup

The very first thing you need to do in order to get the add button to show up in the navigation bar is to embed your view controller in a navigation controller.

Select your view controller and choose Editor > Embed In > Navigation Controller:

Next, you need to search for a Bar Button Item from the Object Library in the Utilities Pane. Once you find it in the list, drag one up to the upper-right of the navigation bar:

To turn it from an “Item” button into a “+” button, you need to adjust the Bar Button Item’s attributes. Click on the button, either in the navigation bar itself or on the document outline for the Storyboard, and choose the Attributes Inspector for the control.

Then change the System Item property from “Custom” to “Add”:

That’s all there is to setting up that first scene. You’ll wire up the add button to modally show the “Add” scene in the next section.

Add Storyboard scene setup

Next up, you need an “Add” scene. For that, another View Controller is required. Drag out a new View Controller onto the Storyboard design surface. While you’re at it, go ahead and create a new AddScreenViewController class:

Once you’ve created a new AddScreenViewController class from the File > New > File dialog, make sure you’ve wired it up appropriately:

Now, to get this “Add” screen to show modally, you need to control + drag from the “plus (+)” button on the first view controller, over to the new AddScreenViewController you just dragged onto the Storyboard. Select “Present Modally” from the popover:

Now, the problem you’ll run into at this point if you run the app is that, while tapping the ‘Add’ (+) button does in fact present the Add screen modally, 1) There’s no way to dismiss the modal controller to go back to the main screen, and 2) There’s no navigation bar to add buttons to!

So, the trick to get a navigation bar in place so that you can add our ‘Cancel’ and ‘Save’ buttons is to embed the Add Screen View Controller in… you guessed it… a Navigation Controller:

Once this is done, your storyboard should look something like this:

Now all that’s left to do is to drag two Bar Button Items up to the navigation bar, just like we did for the “Plus” (+) button on the main screen:

Changing each of their System Item properties in the Attribute Inspector, just like we did before, will give them their “Cancel” and “Save” appearance:

If you control + drag the ‘Cancel’ and ‘Save’ buttons from the Storyboard scene to the .swift code file, you’ll be able to wire up IBActions to dismiss the view controller and return to the main screen. I won’t explain that step here, since the goal was to show you how to add the buttons themselves, but the example project on GitHub has the view controller dismissal implemented if you care to review it.

Wrapping up

That’s it! Buttons in the navigation bar, all done inside the Storyboard.

Hopefully this quick walk-through removes any stumbling blocks you might have in designing your Storyboard-based app with navigation controllers.

Access Sub-Controllers from a UINavigationController in Swift

Tue, 02 Jun 2015 17:37:44 +0000

The sequence of accessing a UINavigationController's first child from within the AppDelegate or within prepareForSegue(_:sender:) always gets me. Here are a few quick snippets to help you and I quickly get up and running when working with navigation controllers in our Swift applications:

AppDelegate

Every iOS application has one root view controller that’s presented when the app finishes its launch process. Suppose we’re building a navigation controller-based app… that is, we’re building an app where the first (root) view controller is a UINavigationController. In our Storyboard, we’ve set up a Scene with some UI controls with a view controller and some properties, and we’ve embedded that view controller in a navigation controller.

What if we want to set some of the view controller’s properties after the app launches? How could we go about doing that?

I tend to always think of the “first view controller” as the first Scene in the Storyboard where I’ve set up UI components. To iOS, however, the navigation controller is actually the first (or root) view controller.

When an app incorporates a navigation controller as its first (root) view controller, we end up needing to do a little digging into the view controller hierarchy to get access what we might perceive as the true “first view controller”.

Digging for the first view controller

Here is a snippet of how to dig into the UINavigationController's view controller hierarchy to grab the first one and set some fictitious properties on it, all from within the AppDelegate:

 1class AppDelegate: UIResponder, UIApplicationDelegate {
 2
 3    var window: UIWindow?
 4
 5
 6    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
 7        // Override point for customization after application launch.
 8        
 9        let navigationController = window?.rootViewController as! UINavigationController
10        let firstVC = navigationController.viewControllers[0] as! NameOfFirstViewController
11        // set whatever properties you might want to set
12        // such as an NSmanagedObjectContext reference
13
14        return true
15    }
16
17    // ...
18}

So the workflow goes like this:

Get the window’s root view controller (which is the navigation controller in our case)
Get the navigation controller’s first view controller from its array of view controllers (which is what I always think of as the “first” view controller)
Set whatever properties you need to set

Note: With iOS 13, the code to access the root view controller needs to go in your app’s SceneDelegate.

You may be worried about the usage of implicitly unwrapped optionals in this snippet. I tend to avoid them wherever possible too, but I used them here because I reasoned that my navigation controller-based app hinges on the fact that the root view controller of the application is a UINavigationController. Something so fundamental to the app warranted my usage of the implicitly unwrapped optionals, since changing the navigation paradigm of the app would probably break things anyway.

If you’re not convinced by that line of reasoning, no worries – you can switch out some of the ! operators for ? operators and add in some if-let syntax to protect against encountering nil. For example:

 1class AppDelegate: UIResponder, UIApplicationDelegate {
 2
 3    // ...
 4    if let navigationController = window?.rootViewController as? UINavigationController {
 5        if let firstVC = navigationController.viewControllers[0] as? NameOfFirstViewController {
 6            firstVC.someProperty = someValue
 7        }
 8    }
 9    // ...
10}

Prepare for segue

What about in prepareForSegue(_:sender:)? When would this even be necessary?

Well, suppose that we have an app which segues into a navigation controller. We may need to pass some data off the next view controller, but that “next view controller” is technically the navigation controller, not the controller where our properties are declared.

In similar fashion to the AppDelegate situation, we want to dig into the navigation controller’s view controller hierarchy to access the first child so that we can pass the data along. Here’s an example implementation:

 1public class ViewController: UIViewController {
 2
 3    // ...
 4    override public func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
 5        
 6        let destinationVC = segue.destinationViewController as! UINavigationController
 7        let nextViewController = destinationVC.viewControllers[0] as! SecondViewController
 8        
 9        nextViewController.someProperty = someValue
10    }
11    // ...
12}

The only thing that really changes between the AppDelegate example and the prepareForSegue example is where we obtain the UINavigationController from. In AppDelegate, the navigation controller comes from the window’s root view controller. In prepareForSegue it comes from the segue’s destination view controller.

After that, though, the process for grabbing the first child of the navigation controller is the same.

Wrapping up

Accessing a navigation controller’s view controller hierarchy was just vague enough for me to write this little reference for myself, but I hope you benefited from it as well!