How does AppDelegate become UIApplication's delegate? - ios

Question

I'm just trying to understand the general architecture of UIApplication. My understanding of using a delegate works something like following:
protocol MyDelegate {
func someProtocolMethod()
}
class SomeClass {
var delegate: MyDelegate!
init(){
}
func someClassMethod(){
self.delegate.someProtocolMethod()
}
}
class ClassConformingToDelegate: NSObject, MyDelegate {
let someClass: SomeClass
override init(){
someClass = SomeClass()
super.init()
someClass.delegate = self // self has to be assigned so that SomeClass's delegate property knows what the conforming class is
}
func someProtocolMethod(){}
}
In a similar fashion, AppDelegate conforms to UIApplicationDelegate by having a number of protocol methods implemented.
class AppDelegate: UIResponder, UIApplicationDelegate {
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
return true
}
// MARK: UISceneSession Lifecycle
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
// Called when a new scene session is being created.
// Use this method to select a configuration to create the new scene with.
return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
}
func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
// Called when the user discards a scene session.
// If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
// Use this method to release any resources that were specific to the discarded scenes, as they will not return.
}
}
UIApplication declares the delegate as following in its class:
unowned(unsafe) var delegate: UIApplicationDelegate?
But, in order for this delegate to know that AppDelegate.swift is the true delegate, UIApplication has to be instantiated and AppDelegate.swift be assigned to the instance, similar to the example above. So something like the following should happen within AppDelegate.swift:
let application = UIApplication()
application.delegate = self
But, how is this step omitted and AppDelegate still works?

Answer 1

The answer to this question varies a little depending on which version of Xcode/Swift/iOS you are talking about, but the essential process is the same.
If you create a project in Xcode that uses the UIKit AppDelegate lifecycle then you will see the line #main at the start of the AppDelegate.swift file.
This tells the compiler that this file contains the UIApplicationDelegate implementation. The compiler then synthesises a main function for you that performs all of the required setup, including creating an instance of the AppDelegate and assigning it to the UIApplication instance.
In earlier versions of Swift you would see #UIApplicationMain that does essentially the same thing.
You can omit the #main/#UIApplicationMain and create your own main that does all of the required work, but this generally isn't required.
With SwiftUI you now have the option of using SwiftUI lifecycle rather than UIKit lifecycle when you create the project. In this case you have an App struct. This file still contains the #main and is used to launch your app's view hierarchy.