
<LeadParagraphWrapper>
There are several phases involved in launching an application, most of which the system handles automatically. 
The operating system calls methods in your app delegate during the launch sequence, allowing you to prepare your app for user interaction. 
The system provides some initial instances and an initial interface to run.
</LeadParagraphWrapper>

### The Entry Point

 When the app launches, the system knows where to find compiled binary within the app bundle. 
 Thanks to `info.plist` in the same bundle, this file has an executable file key(`CFBundleExecutable`) whose value is the name of the app’s binary.

 The system loads the binary and links any required frameworks. Now it needs to execute a code from the app’s binary to launch it. But where?

The answer would be obvious if this app were an Objective-C program. 
Objective-C is derived from C programing language, so the entry point is main function. Objective-C project would have a `main.m` file containing the main function:

``` swift
int main(int argc, char *argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil,
                                 NSStringFromClass([AppDelegate class]));
    }
}
```

The main function performs two tasks:
- It creates an environment for memory management, thanks to `@autoreleasepool`.
- It executes the `UIApplicationMain` function, which enables your application to use its bootstraps to set itself up and running.

If our app is Swift program, it has no `main` function. Rather, Swift has a specific attribute: `@main`. You can see it in the `AppDelegate.swift` file where AppDelegate class is defined.

``` swift
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        return true
    }
}
```

Basically, this property handles all of the functionality Objective-C main.m file: it creates an entry point that executes `UIApplicationMain` to launch the app.

> Note: Swift 5.3 introduced the @main term; this attribute was formerly known as @UIApplicationMain.

It would be very uncommon, but you can create a `main.swift` file like Objective-C main file. 
Delete the `@main` attribute and instead use main file. This file, main.swift, gets special treatment, so the name is critical.

This file has also another special ability, it will execute code at the top level of the file, outside any function body. Other swift files, all executable code lives in a function. 
From a specific angle, computer programs just calls functions in the related files. Swift equivalent of the Objective-C call to UIApplicationMain, like this:

``` swift
import UIKit
UIApplicationMain(
    CommandLine.argc, CommandLine.unsafeArgv, nil,
    NSStringFromClass(AppDelegate.self)
)
```
You are calling the UIApplicationMain function in a iOS application. 
**The main task of your application is this function call.** 
All your application really does is make one massive call to UIApplicationMain.

![images/AppStateTransitions](/images/posts/2/LaunchSequence.jpeg)

### SwiftUI App Life Cycle

By default, when you make a new SwiftUI application, there is no `AppDelegate` class in the application that is generated. It has been replaced by an struct that conforms to the `App` protocol. Similar to how SwiftUI creates structs for views, it also use struct for launch process with a `@main` attribute. 

``` swift
import SwiftUI

@main
struct SwiftUIApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
```
You might need to revert to the previous version of the UIApplicationDelegate ability - possibly to handle push notification registration or or 3rd party library integration(Firebase etc.). 

First, create a AppDelegate class that inherits from “NSObject” and conforms to the “UIApplicationDelegate” protocol, like this:

``` swift
class AppDelegate: NSObject, UIApplicationDelegate {
    func application(_ application: UIApplication, 
                    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        configureApp()
        return true
    }

    private func configureApp() {
        // Add any configuration steps here.
        print("Application launched!")
    }
}
```
After that, you can add a reference to the AppDelegate file in your App.swift file with `UIApplicationDelegateAdaptor` property wrapper.

``` swift
@main
struct SwiftUIApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
```

### App State Transitions

The state transitions can be tracked by implementing UIApplicationDelegate callbacks with AppDelegate or SceneDelegate, it depends on how new the project is.

![images/AppStateTransitions](/images/posts/2/AppStateTransitions1.jpeg)

### Pre-warming

With iOS15 and later, the system might decide to pre-warm your app before the user tries to open it. 
This process minimizes the length of time the user has to wait before the app is usable. 
Pre-warming runs the launch sequence of an application until `main()` calls `UIApplicationMain` methods, but not beyond that point. 
This helps the system to build and cache any low-level structures that are needed.

Once your app is prewarmed by the system, its launch sequence is halted until the app starts or the system kills the prewarmed app from memory in order to reclaim resources. 
The system can prewarm your app after every device reboot. 

If your application runs code before the calling `UIApplicationMain` methods, such as <a href="https://developer.apple.com/documentation/objectivec/nsobject/1418815-load" target="_blank" rel="noopener">load()</a>, be careful when assuming which resources and services are available. 
For instance, keychain items could not be available because their data protection policies need an unlocked device status.

#### Key Points

- **Entry Point:** Objective-C programs have a traditional main function, while Swift programs use the `@main` attribute or a `main.swift` file to initiate the application launch sequence.
- **SwiftUI App Lifecycle:** SwiftUI apps replace the traditional `AppDelegate` with a struct conforming to the `App` protocol, simplifying the initialization process with a `@main` attribute.
- **Pre-warming:** iOS 15 introduced app pre-warming, which initiates parts of the launch sequence to reduce user wait times.
- **Executable File Identification:** The system identifies the executable file of an app through the info.plist file, crucial for locating and launching the application's binary.

Tagged with #ios

The App Launch Sequence