Support free tutorials

vogella training Training Books

Android application and activity lifecycle - Tutorial

Based on Android 4.2

Lars Vogel

Version 1.1


Revision History
Revision 0.1 04.07.2013 Lars Vogel Created
Revision 0.2 - 1.1 05.07.2013 - 13.08.2013   bug fixing and enhancements

Understanding the Android lifecycle

This tutorial describes how the Android application and activity lifecycle works.

Table of Contents

1. Managing the application life cycle
2. Application
3. Activity lifecycle
4. Activity instance state
5. Nonconfiguration instance scope
6. Controlling configuration
6.1. Avoiding configuration change restarts
6.2. Fixing the orientation for an activity
7. Exercise: Lifecycle
7.1. Prepare project
7.2. Testing
7.3. Instance state
8. Support this website
8.1. Thank you
8.2. Questions and Discussion
9. Links and Literature
9.1. Source Code
9.2. Android ActionBar Resources
9.3. vogella Resources

1. Managing the application life cycle

Android devices have limited resources, therefore the Android system is allowed to manage the available resources by terminating running processes or recycling Android components.

In addition to resource management, Android also recreates activities in case a configuration change occurs. The Configuration object contains the current device configuration, if this configuration changes activities are restarted, as they may use different resources for this configuration.

For the user of the device this should happen transparently, i.e. he should not note if an Android component have been terminated nor not.

To support this the Android platform supports lifecycle event which are called in the case of process or component termination as well as in case of a configuration change. The developer is responsible for maintaining the state of the application. He is also responsible for restore the activity instance state. The instance state of an activity is the nonpersistent data that needs to be passed between activities restarts during a configuration change to restore user selections.

2. Application

The application object is created whenever one of your Android components are started. It is started in a new process with a unique ID under a unique user. Even if you do not specify one in your AndroidManifest.xml file, the Android system creates a default object for you. This object provides the following main lifecycle methods:

  • onCreate() - called before the first components of the application starts

  • onLowMemory() - called when the Android system requests that the application cleans up memory

  • onTerminate() - only for testing, not called in production

  • onConfigurationChanged() - called whenever the configuration changes

The application object starts before any component and runs at least as long as another component of the application runs.

If the Android system needs to terminate processes it follows the following priority system.

Table 1. Priorities

Process status Description Priority
Foreground An application in which the user is interacting with an activity, or which has an service which is bound to such an activity. Also if a service is executing one of its lifecycle methods or a broadcast receiver which runs its onReceive() method. 1
Visible User is not interacting with the activity, but the activity is still (partially) visible or the application has a service which is used by a inactive but visible activity. 2
Service Application with a running service which does not qualify for 1 or 2. 3
Background Application with only stopped activities and without a service or executing receiver. Android keeps them in a least recent used (LRU) list and if requires terminates the one which was least used. 4
Empty Application without any active components. 5

3. Activity lifecycle

The Android system is also allowed to recycle Android components to free up resources. This part explains which for activities, the lifecycle of other components is described in the respective part of these components.

An activity can be in different states which are described by the following table.

Table 2. Activity state

State Description
Running Activity is visible and interacts with the user.
Paused Activity is still visible but partially obscured, instance is running but might be killed by the system.
Stopped Activity is not visible, instance is running but might be killed by the system.
Killed Activity has been terminated by the system of by a call to its finish() method.

The user should not notice if an activity which is still part of an activity stack has been terminate or not. For this the developer needs to store the state of the activity at the right point in time and restore it. He also should stop any unnecessary actions if the activity is not visible anymore to save system resources.

The Android system defines a lifecycle for activities via predefined (lifecycle) methods. The most important methods are:

Table 3. Important Activity lifecycle methods

Method Purpose
onCreate() Called then the activity is created. Used to initialize the activity, for example create the user interface.
onResume() Called if the activity get visible again and the user starts interacting with the activity again. Used to initialize fields, register listeners, bind to services, etc.
onPause() Called once another activity gets into the foreground. Always called before the activity is not visible anymore. Used to release resources or save application data. For example you unregister listeners, intent receivers, unbind from services or remove system service listeners.
onStop() Called once the activity is no longer visible. Time or CPU intensive shut-down operations, such as writing information to a database should be down in the onStop() method. This method is guaranteed to be called as of API 11.

The life cycle of an activity with its most important methods is displayed in the following diagram.

Activity life cycle

Android has more life cycle methods but not all of these methods are guaranteed to be called. The onDestroy() method is not guaranteed to be called, hence you typically do not use it. For more information on the other methods see Activity lifecycle - Official documentation.


You can safely ignore the existing of the other lifecycle methods. Applications are typically developed having other lifecycle methods.

4. Activity instance state

Instance state of an activity which is required to restore the activity to the state in which the user left it.

Assume for example the user scrolled through a ListView with thousands of items and the activity is recreated. Loosing the position in the list is annoying for the user, hence the position should be restored.

The onSaveInstanceState() can be used to store this instance state as a Bundle. A Bundle can contain primitive data types, arrays, String and objects which are of the Parcelable or Serialisable type.

The persisted Bundle data is passed at restart of the activity to the onCreate() method and onRestoreInstanceState() as parameter.

If you override onSaveInstanceState() and onRestoreInstanceState() you should call the super implementation of it, because the default views of Android store their data via a call to View.onSaveInstanceState from the onSaveInstanceState() method of the activity. For example EditText stores its content via the default call of this method.

The onRestoreInstanceState() or the onCreate() methods can be used to recreate the instance scope of an activity if it is restarted.


Prefer using the onRestoreInstanceState() method for restoring the instance state. This approach separates the initial setup from restoring the state.

If the user interacts with an activity and presses the Back button or if the finish() method of an activity is called, the activity is removed from the current activity stack and recycled. In this case there is no instance state to save and the onSaveInstanceState() method is not called.

If the user interacts with an activity and presses the Home button, the activity instance state must be saved. The onSaveInstanceState() method is called. If the user restarts the application it will resume or restart the last running activity. If it restarts the activity it provides the bundle with the save data to the onRestoreInstanceState() and onCreate() methods.


The onSaveInstanceState() method is not called if the user presses the back button. Don't use this approach to save the data which needs to get persisted.

5. Nonconfiguration instance scope

Nonconfiguration instance scope are Java objects which need to passed from one instance to the next instance of an activity in case of an configuration change.

Saving and restoring one object was possible with the getLastNonConfigurationInstance() and onRetainNonConfigurationInstance() methods. These methods have been deprecated, you should prefer using headless retained fragments for holding to objects which should be passed between activity instances due to configuration changes.


If you still using the approach of the onRetainNonConfigurationInstance() method, ensure that you are not passing objects to the next instance which have a reference to the current instance of the activity. Otherwise you have created a memory leak, i.e. the garbage collector cannot clean up the other instance of the activity as you are still holding on to a reference of it.

6. Controlling configuration

6.1. Avoiding configuration change restarts

An activity is restarted if a configuration change occurs. A configuration change happens if an event is triggered from the actual the Android device which may be relevant for the application.

An instance of the Configuration class defines the current configuration of the device. Typical configuration is the device orientation, the locale the smallest width, etc.

For example if the user changes the orientation of the device (vertically or horizontally). Android assumes that an activity might want to use different resources for these orientations and restarts the activity.

In case an activity is restarted the programmer must ensure that the activity is recreated in the same state as before the restart. The Android provides several potential means for doing this.

In the emulator you can simulate the change of the orientation via the Ctrl+F11 shortcut.

You can avoid a restart of your application for certain configuration changes via the configChanges attribute on your activity definition in your AndroidManifest.xml. The following setting avoids an activity restart incase of orientation changes or position of the physical keyboard (hidden / visible).

<activity android:name=".ProgressTestActivity"


Avoid using the configChanges attribute if possible. It is typically better to use other means to handle configuration changes, like the Android loader framework or headless retained fragments. These concept are covered later.

6.2. Fixing the orientation for an activity

It is also possible to define that an activity should only be used in a specific screen orientation via the AndroidManifest.xml file. Such an example configuration is listed below.

   android:screenOrientation="landscape" >
      <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />

7. Exercise: Lifecycle

7.1. Prepare project

Create a new project called

Create the following class which is used to report lifecycle events via notifications.


import android.os.Bundle;

public class TracerActivity extends Activity {

  protected void onCreate(Bundle savedInstanceState) {

  protected void onPause() {

  protected void onResume() {

  protected void onStop() {

  protected void onDestroy() {

  protected void onRestoreInstanceState(Bundle savedInstanceState) {

  protected void onSaveInstanceState(Bundle outState) {

  private void notify(String methodName) {
    String name = this.getClass().getName();
    String[] strings = name.split("\\.");
    Notification noti = new Notification.Builder(this)
        .setContentTitle(methodName + " " + strings[strings.length - 1]).setAutoCancel(true)
    NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
    notificationManager.notify((int) System.currentTimeMillis(), noti);


Create two activity which extend this one. The first activity should allow to start the second one via an Intent.

7.2. Testing

Start your application and trigger the second activity. Review the notifications and ensure you know why this order of things are happening.

Notifications about the lifecycle

Press the Back button on the second activity. Validate that onSaveInstanceState() is not called. Explain why it is not called.

Press the home button on the second activity. Validate that onSaveInstanceState() is called. Explain why it is called.

Start the second activity. Switch the orientation of your emulator via the CTRL+F11 shortcut and see which lifecycle methods of the activity are called. Is the first activity also re-created or only the second one?

Activate the Don't keep activities setting in the Developer Options. Test again which methods are called.

7.3. Instance state

Create a string array and add a spinner to your first activity using this array. The following lists the strings.xml and the layout file used by the first activity.

<?xml version="1.0" encoding="utf-8"?>

    <string name="app_name">Lifecycle</string>
    <string name="action_settings">Settings</string>
    <string name="hello_world">Hello world!</string>
    <string-array name="operating_systems">
        <item >Ubuntu</item>
        <item >Android</item>
        <item >iOS</item>


<LinearLayout xmlns:android=""
    tools:context=".MainActivity" >

        android:entries="@array/operating_systems" />

        android:text="Start new Activity" />


Ensure that the selection of the spinner is saved and restored between configuration changes or restarts of the activity by the Android system.

8. Support this website

This tutorial is Open Content under the CC BY-NC-SA 3.0 DE license. Source code in this tutorial is distributed under the Eclipse Public License. See the vogella License page for details on the terms of reuse.

Writing and updating these tutorials is a lot of work. If this free community service was helpful, you can support the cause by giving a tip as well as reporting typos and factual errors.

8.1. Thank you

Please consider a contribution if this article helped you. It will help to maintain our content and our Open Source activities.

8.2. Questions and Discussion

If you find errors in this tutorial, please notify me (see the top of the page). Please note that due to the high volume of feedback I receive, I cannot answer questions to your implementation. Ensure you have read the vogella FAQ as I don't respond to questions already answered there.

9. Links and Literature

9.1. Source Code

Source Code of Examples

9.2. Android ActionBar Resources

Android Design Page

Android ActionBar Sherlock

9.3. vogella Resources

vogella Training Android and Eclipse Training from the vogella team

Android Tutorial Introduction to Android Programming

GWT Tutorial Program in Java, compile to JavaScript and HTML

Eclipse RCP Tutorial Create native applications in Java

JUnit Tutorial Test your application

Git Tutorial Put all your files in a distributed version control system