Table of contents

Introduction

1.1.

Application lifecycle in iOS

1.2.

Steps involved from device reboot to device launch

Execution states for Applications

Mapping app states with code

The flow of the iOS app cycle from launch to suspended states

Frequently Asked Questions

5.1.

How is a background iOS app brought to the foreground?

5.2.

What are the actions to take when an app is brought to the foreground after the device has been rebooted?

5.3.

How does an iOS app handle interruptions such as SMS, Incoming Call, Calendar, and so on?

5.4.

What are the benefits of having a background state?

5.5.

Can a user’s location be used in another way if he has been denied permission to track his location?

Conclusion

Last Updated: Mar 27, 2024

iOS App Cycle

Author Vaibhav Agarwal

Do you think IIT Guwahati certified course can help you in your career?

Yes

Introduction

This article will discuss the iOS app cycle and the different execution states of the iOS app cycle, and we will look at the flow of the app lifecycle from launch to suspended states.

Application lifecycle in iOS

The state of the Application life cycle refers to the several stages an iOS application goes through. Every iOS developer should be familiar with the app life cycle, as it aids in understanding the app's behavior.

Steps involved from device reboot to device launch

When a user turns on the phone, no applications are running except those that are part of the operating system. SpringBoard runs your app when a user taps on its icon The usual application for managing the iPhone's home screen is SpringBoard. The other duties are starting WindowServer, launching and bootstrapping programs, and configuring some of the device's settings on startup.
Your app and any required shared libraries will be loaded into memory while springboard animates your app's launch screen. Your app will eventually start running, and the application delegate will receive notifications

The application delegate object is AppDelegate.
It inherits from UIResponder and follows the UIApplicationDelegate delegate protocol.

UIApplicationDelegate is the entry point into iOS apps. It is a protocol you must implement into your app to be alerted of user events such as app start, app switching to the background or foreground, app termination, or the opening of a push notification.
AppDelegate can reply to user events thanks to the UIResponder class, and the UIApplicationDelegate class allows it to manage and respond to the application's life cycle.

Recommended Topic, procedure call in compiler design

Execution states for Applications

States of iOS App Cycle

Not Running: When an app is not yet started or terminated by the system or a user, it is said to be in a Not Running state.
Inactive: When an app is in the forefront but receiving events, it is in an inactive state. In other words, it works as a bridge state, where the app stays for a short time before transitioning to another state.
Active: This is the usual mode when the app is in the foreground and receiving all user events.
Background: When the user touches the home screen while using the program, it changes to the background state or requires additional execution time. When the app is about to be suspended, it also enters this state for a brief period of time. The program remains in the background and executes the code in this state.
Suspended: The program remains in the background and does not run the code in this mode. This is the state in which the app is automatically placed. The app is still in memory in this mode. Foreground apps, on the other hand, always take precedence over suspended apps and can be removed at any time without warning.

When we build and run an iOS app in XCode, we should keep in mind that the main entry point of the app is UIApplicationDelegate, which is a protocol that the app must implement to be notified of various user events such as app launch, app background, app foreground, push notifications, and so on.

Certain app lifecycle methods are triggered when the app starts operating and are stored in the UIApplicationDelegate. The methods of the UIApplicationDelegate are listed below.

application:willFinishLaunchingWithOptions: This method is invoked when your program has successfully launched. It is our app delegate's initial method that will be invoked. If the launch was successful, you could run your code.
application:didFinishLaunchingWithOptions : Before the app's window is displayed, this function is called. You can now finish your interface and give the window the root ViewController.
applicationDidBecomeActive : This method is used to notify your app that it has changed from the inactive to an active state, that it has been launched by the user or the system, or that the user has ignored an interruption (such as an incoming phone call or SMS message) that has temporarily put the program in the inactive state. This method should be used to resume any tasks that were halted (or had not yet begun) while the app was dormant.
applicationWillResignActive : This method is used to notify your app that it is about to transition from active to dormant. This can happen if the user quits the program or if there are any interruptions (such as an incoming phone call, SMS message, or Calendar alerts). This function should be used to pause any running tasks or disable timers, among other things.
applicationDidEnterBackground : This approach is used to inform the app that it is not at the forefront. You have around five seconds to do any activities and then return. If you require more time, you can request it from the system by executing beginBackgroundTask (expirationHandler:). If the method does not return before the timer expires, your program will be killed and memory will be cleared.
applicationWillEnterForeground : As part of the transition from the background to the active state, this procedure is called. This should be used to undo any changes done to your program while it was in the background. After this method has been completed, the applicationDidBecomeActive method is called, which changes the app's status from inactive to active.
applicationWillTerminate : This method is used to notify you that your app is about to exit. Any final clean-up task should be completed using this manner. You have around five seconds to do any activities and then return. If the method does not return before the time limit has expired, the system may terminate the process. When an app is operating in the background (not suspended) and the system wants to terminate it for some reason, this function is called. To save your data, you should not wait for applicationWillTerminate to be called. In some circumstances, applicationWillTerminate will not be called before the app is terminated. When the device reboots, for example, the OS will not call applicationWillTerminate.

Mapping app states with code

@UIApplicationMain class AppDelegate : UIResponder, UIApplicationDelegate
{ 
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool{
        // After the application has been launched, override this point for customisation.              
        return true
    }
    func applicationWillResignActive(_ application
                                     : UIApplication){
        // When the application is about to transition from active to dormant mode, this message is sent. This can happen as a result of temporary disruptions (such as an incoming phone call or SMS message) or when the user exits the programme and it transitions to the background.
        // To suspend running jobs, disable timers, and invalidate graphics rendering callbacks, use this function. This method should be used to pause games.
    }
    func applicationDidEnterBackground(_ application
                                       : UIApplication){
        // / Use this function to free shared resources, preserve user data, invalidate timers, and save enough application state information to restore your programme to its previous state if it is stopped later.
        // When the user exits your application, this method is invoked instead of applicationWillTerminate: if your application supports background execution.
    }

    func applicationWillEnterForeground(_ application
                                        : UIApplication){
        //  Called as part of the transition from the background to the active state; you can undo a lot of the changes you did when you first went into the background.
        Utile.getCurrentViewController() ?.viewDidLayoutSubviews() }

        func applicationDidBecomeActive(_ application
                                        : UIApplication){

        // Any tasks that were halted (or not yet started) while the app was dormant should be restarted. Refresh the user interface if the application was previously in the background.
    }
    func applicationWillTerminate(_ application
                                  : UIApplication){
        // When the application is going to exit, this method is called. If necessary, save data. applicationDidEnterBackground is another option.:.
    }
}

The flow of the iOS app cycle from launch to suspended states

Frequently Asked Questions

How is a background iOS app brought to the foreground?

When a user runs an app that is currently running in the background, the system switches it from inactive to active mode.

What are the actions to take when an app is brought to the foreground after the device has been rebooted?

The system changes an app to the active state when the user runs it for the first time, after a device reboot, or after the program is terminated by the system.

How does an iOS app handle interruptions such as SMS, Incoming Call, Calendar, and so on?

The application goes into a temporarily inactive state and stays there until the user decides whether to accept or disregard the interruption. The application is reactivated if the user ignores the interruption and enters a suspended state if the user accepts the interruption.

What are the benefits of having a background state?

It allows users to save any program data, allowing them to relaunch the software from where they left it and any resources that are no longer required by the app are released.

Can a user’s location be used in another way if he has been denied permission to track his location?

No, without the user’s permission there is no other way to track his location.

Conclusion

In this article, we discussed the iOS app cycle, the execution state of the iOS app cycle, and the flowchart of the iOS app cycle from launch to suspended states.

To further study the ios development you can refer to this blog on coding ninjas

IOS App Development.

Refer to our Guided Path on Coding Ninjas Studio to upskill yourself in Data Structures and algorithms, Competitive Programming, JavaScript, System Design, Machine learning, and many more! If you want to test your competency in coding, you may check out the mock test series and participate in the contests hosted on Coding Ninjas Studio! But if you have just started your learning process and are looking for questions asked by tech giants like Amazon, Microsoft, Uber, etc; you must look at the problems, interview experiences, and interview bundle for placement preparations.

Nevertheless, you may consider our paid courses to give your career an edge over others!

Do upvote our blogs if you find them helpful and engaging!

Happy Learning!!