mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-0

Latest Mobile Dev Insights: iOS, Android, Cross-Platform

Advertise with Us|Sign Up to the Newsletter

MobilePro #188: Android's Activity Lifecycle—A Sneak Peek Behind the Curtain

FREE GUIDE: Airflow 3 Tips & Code Snippets

Thinking about upgrading to Apache Airflow® 3? You’ll get powerful new features like a modernized UI, event-based scheduling, and streamlined backfills. Quick Notes: Airflow 3 Tips & Code Snippets is a concise, code-filled guide to help you start developing DAGs in Airflow 3 today.

You’ll learn:

How to run Airflow 3 locally (with dark mode) and navigate the new UI
How to manage DAG versioning and write DAGs with the new @asset-oriented approach
The key architectural changes from Airflow 2 to 3

GET YOUR FREE GUIDE

Hi ,

Welcome to the 188th edition of MobilePro!

Think of your Android app like a stage play. When the curtain rises, the actors (your activities) step into the spotlight, ready to perform. Sometimes they pause mid-scene while the spotlight shifts, sometimes they step into the wings to wait for their cue, and eventually, they exit the stage entirely. The audience may not notice all the behind-the-scenes work, but as the developer, you’re the stage manager making sure the transitions are smooth and the show goes on without a hitch.

So, every time your app is opened, backgrounded, resumed, or closed, it passes through well-defined stages. Android provides callback methods—like cues in a script—that let you know when it’s time to set the scene, save the current state, or clean things up. Mastering these callbacks means your app won’t drop the ball when a user takes a call, rotates their screen, or swipes it away from the task list.

In this article, we’ll break down the key lifecycle callbacks step by step, showing you how they work and how you can use them to keep your apps running smoothly. This is excerpted from the book How to Build Android Applications with Kotlin, written by Alex Forrester, Eran Boudjnah, Alexandru Dumbravan, and Jomar Tigcal.

Before we jump in though, let's take a quick look at last week's highlights:

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-1

Take the Survey!

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-2

3rd Sept

Why Cloud, Why Now?

Join Forrester & Atlassian to understand costs, risks, and AI opps.

Join now

Meet the Authors

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-3

Alex F

Senior Android Developer
NatWest Group

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-4

Eran B

Director
Mitteloupe Limited

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-5

Alexandru D

Principal Android Engineer
Nutmeg

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-6

Jomar T

Lecturer
De La Salle University

♻️ The Activity Lifecycle

Imagine you’re using your favorite app, scrolling through a feed, when suddenly you get a phone call. The app disappears into the background, but when you return a few minutes later, everything is right where you left it. Or perhaps you rotate your phone, and the screen smoothly reorients itself without losing sight of what was onscreen. While regular users may not be aware that these little moments of continuity don’t happen by accident; you are likely to know that this is a result of Android’s activity lifecycle.

For every one of these steps, there is a callback that your activity can use to perform actions such as creating and changing the display, saving data when your app has been put into the background, and then restoring that data after your app comes back into the foreground.

These callbacks are made on the parent activity, and it’s up to you to decide whether you need to implement them in your own activity to take any corresponding action. Each of these callback functions has the override keyword. The override keyword in Kotlin means that either this function is providing an implementation of an interface or an abstract method; or, in the case of your activity here, which is a subclass, it is providing the implementation that will override its parent.

Now that you know how the activity lifecycle works in general, let’s first dive into the flow of callbacks and events, which is illustrated in the following diagram:

mobilepro-188-androids-activity-lifecycle-a-sneak-peek-behind-the-curtain-img-7

↩️ Callbacks

Now that you’ve taken in this flow of events, let us go into further detail about the principal callbacks you will work with in order, from creating an activity to the activity being destroyed:

override fun onCreate(savedInstanceState: Bundle?): This is the callback that you will use the most for activities that draw a full-sized screen. At this stage, after the method has finished, it is still not displayed to the user, although it will appear that way if you don’t implement any other callbacks. You usually set up the UI of your activity here by calling the setContent{…} method and carrying out any initialization that is required.
This method is only called once in its lifecycle, unless the activity is created again. This happens by default for some actions (such as rotating the phone from portrait to landscape orientation). The savedInstanceState parameter of the Bundle? type (? means the type can be null) in its simplest form is a map of key-value pairs optimized to save and restore data.
It will be null if this is the first time that an activity has been run after the app has started, if an activity is being created for the first time, or if an activity is being recreated without any state being saved.
override fun onRestart(): When an activity restarts, this is called immediately before onStart(). It is important to be clear about the difference between restarting an activity and recreating an activity. When an activity is backgrounded by pressing the Home button, when it comes back into the foreground again, onRestart() will be called. Recreating an activity is what happens when a configuration change happens, such as the device being rotated. The activity is finished and then created again, in which case, onRestart() will not be called.
override fun onStart(): This is the first callback made when an activity is brought from the background to the foreground.
override fun onRestoreInstanceState(savedInstanceState: Bundle?): If the state has been saved using onSaveInstanceState(outState: Bundle?), this is the method that the system calls after onStart(), where you can retrieve the Bundle state instead of restoring the state using onCreate(savedInstanceState: Bundle?).
override fun onResume(): This callback is run as the final stage of creating an activity for the first time, and also when the app has been backgrounded and then is brought into the foreground. Upon the completion of this callback, the activity is ready to be used and receive user events.
override fun onSaveInstanceState(outState: Bundle?): If you want to save the state of an activity, this function can do this for you. You add key-value pairs using one of the convenience functions, depending on the data type. The data will then be available if your activity is recreated in onCreate(saveInstanceState: Bundle?) and onRestoreInstanceState(savedInstanceState: Bundle?).
override fun onPause(): This function is called when an activity starts to be backgrounded or another dialog or activity comes into the foreground.
override fun onStop(): This function is called when an activity is hidden, either because it is being backgrounded or another activity is being launched on top of it.
override fun onDestroy(): This is called by the system to kill an activity when system resources are low, when finish() is called explicitly on the activity, or, more commonly, when an activity is killed by the user swiping up to close the app from the Overview menu.

At the end of the day, the activity lifecycle is like stage directions for your app. Each callback tells you when to set the scene, when to pause, and when to take a bow. Master these cues, and your app won’t just run; it’ll deliver a performance worth a standing ovation.

If you want to learn more about Android and its functions, then How to Build Android Applications with Kotlin is the book for you!