How an App Launches
Your app’s root view controller is the link between your app’s UIWindow and the interface that it
contains. The initial view controller is instantiated, and that instance is assigned to the window’s roo
tViewController property. It is now the app’s root view controller, and its view henceforth
occupies the entirety of the window. The root view controller itself will be the top of the view
controller hierarchy, of which I’ll have much more to say in Chapter 6.
But how does your app, at launch time, come to have a main window in the first place, and how does
that window come to be populated and displayed? If your app uses a main storyboard, it all happens
automatically. Your app consists, ultimately, of a single call to the UIApplicationMain function.
(Unlike an Objective-C project, a typical Swift project doesn’t make this call explicitly, in code; it is
called for you, behind the scenes.) Here are some of the first things this call does:
1. UIApplicationMain instantiates UIApplication and retains this instance, to serve as the shared
application instance, which your code can later refer to as UIApplication.shared. It then
instantiates the app delegate class. (It knows which class is the app delegate because it is
marked @UIApplicationMain.) It retains the app delegate instance, thus ensuring that it will
persist for the lifetime of the app, and assigns it as the application instance’s delegate.
2. UIApplicationMain looks to see whether your app uses a main storyboard. It knows whether
you are using a main storyboard, and what its name is, by looking at the Info.plist key “Main
storyboard file base name” (UIMainStoryboardFile). You can easily edit this key, if
necessary, by editing the target and, in the General pane, changing the Main Interface value in
the Deployment Info section. By default, a new iOS project has a main storyboard called
Main.storyboard, and the Main Interface value is Main.
3. If your app uses a main storyboard, UIApplicationMain instantiates UIWindow and assigns
the window instance to the app delegate’s window property, which retains it, thus ensuring that
the window will persist for the lifetime of the app. It also sizes the window so that it will
initially fill the device’s screen. This is ensured by setting the window’s frame to the screen’s
bounds. (I’ll explain later in this chapter what “frame” and “bounds” are.)
4. If your app uses a main storyboard, UIApplicationMain instantiates that storyboard’s initial
view controller. (I’ll talk more about that in Chapter 6.) It then assigns this view controller
instance to the window’s rootViewController property, which retains it. When a view
controller becomes the main window’s rootViewController, its main view (its view) is made
the one and only immediate subview of your main window — the main window’s root view. All
other views in your main window will be subviews of the root view.
Thus, the root view is the highest object in the view hierarchy that the user will usually see.
There might be just a chance, under certain circumstances, that the user will catch a glimpse of
the window, behind the root view; for this reason, you may want to assign the main window a
reasonable backgroundColor. In general you’ll have no reason to change anything else about