Activity and Its Lifecycle in Android

Introduction

An Activity is an application's component that enables the user to interact to do a view of something, such as dial the phone, take a photo, send an email, or view a map. Basically the Activity is something that a user is doing or interacting on the screen to view something.

For example take an Email application in which there are various components like reading a mail, composing a mail and/or deleting a mail. Let us take the example of composing a mail in which a user starts texting on the screen. So that is an Activity in which the user is interacting with the screen.

An application is a combination of various Activities that are loosely bound to each other. Although there are various Activities but there is a main Activity that appears on the home page while launching and it is visible at the very first glance when the launching is called the main Activity.

The Activity follows the mechanism of a stack based rule and forms an Activity stack. When a new Activity is launched it is placed on the top of the stack.

Activity Lifecycle

The Activity lifecycle is a lifespan of an Activity starting from onCreate() until onDestroy() being called. This procedure covers not only one cycle but it covers the following three cycles:

• Entire Lifetime
• Visible Lifetime
• Foreground Lifetime
  

Entire Lifetime

As mentioned above an Activity is started from the creation and the calling of the onCreate() method until the onDestroy() method is called. At least an Activity should do a setup of a "global" state (such as defining the layout) in the onCreate() method and might release all the remaining resources in the onDestroy() method call.

Let us take an example in which we create a Thread and it is accessing a resource. The thread starts executing after onCreate() is invoked and continues in the running state until onDestroy() is called.

Visible Lifetime

The Visible Lifetime of an Activity is the life between the call to onStart() and until onStop() is invoked. During this time, the user can see the Activity on-screen and interacts with it. After onStop() is invoked then it goes to either onDestroy() or the system might call onStart() and onStop() multiple times during the entire lifetime of the Activity, as the Activity alternates between being visible and hidden from the user because after onStop() the Activity is no longer visible.

Foreground Lifetime

The Foreground Lifetime of an Activity is the life span between the call to onResume() and the call to onPause(). This time, the Activity is in front of all other activities on the screen and tend to take input from the user. An Activity can frequently transition to and from the foreground. Let us take an example such as when onPause() is called when the device goes to sleep or when a dialog appears or the user receives a call from another person. Because this state transition can occur often, the code in these two methods should be fairly lightweight because the heavy code could lead to slow resumption.



Figure: This illustrates the entire life cycle of an Activity and sequential calling of methods.

A simple code is given below. It just shows how to write the methods. Here we are not linking any references from other resources, in other words no other methods are used to take reference and the arguments as well are not given in some methods.

import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;


public class MainActivity extends ActionBarActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    protected void onStart(Bundle savedInstanceState)
    {
    super.onStart();
      setContentView(R.layout.activity_main);
    }
    @Override
    protected void onResume() {
        super.onResume();
        // The activity has become visible .
    }
    @Override
    protected void onPause() {
        super.onPause();
        }
        // Another activity is taking focus

    @Override
    protected void onStop() {
        super.onStop();
    }
        // The activity is no longer visible

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // The activity is about to be destroyed.
    }
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);

Here it does not produce any output and it is just for illustration purposes. 

onCreate()

This method creates an activity as shown in the code and it is the very first state as shown in the diagram. This is where we should do all of our initial static set up like create views, bind data to lists and so on. This method is ed a Bundle object containing the activity's previous state. It is always followed by the onStart() method. Note it is not killable by the system.

onRestart()

This method is called after the activity has been stopped, just prior to it being started again. It is always followed by the onStart() method. Note it is also not killable by the system.

onStart()

This method is called just before the activity becomes visible to the user. It is followed by onResume() if the activity comes to the foreground, or onStop() if it becomes hidden. Note it also not killable by the system.

onResume()

This method is always called just before the activity starts interacting with the user. At this point the activity is at the top of the activity stack, with the user input going to it. It is always followed by the onPause() method. Note it also not killable by the system.

onPause()

This method is called when the system is about to start resuming another activity. This method is generally used to commit unsaved changes to persistent data and to stop animations and other things that may be consuming CPU and activities that becomes halted. It should do whatever it does very quickly, because the next activity will not be resumed until it returns. Again this method is followed either by onResume() if the activity returns back to the front or by onStop() if it becomes invisible to the user. Note that it is killable by the system.

onStop()

This method is always called after the onPause() method and also when the activity is no longer visible to the user. This might happen because it is being destroyed, or because another activity has been resumed and is overwriting it. It is followed either by onRestart() if the activity is returning to interact with the user or by onDestroy() if this activity is going away. Note that it is also killable by the system.

onDestroy()

This is the last method in the activity lifecycle after an Activity becomes shut down and vanishes from the screen completely. This is the final call that the activity will receive. It would be called either because the activity is finishing by calling the onFinish() method or because the system is temporarily  destroying this instance of the activity to save space.

Note: All the killing of methods would happen only in extreme circumstances when there is no other resource.

Summary

This article just tries to explain the Activity life cycle and various method calls involved. This is very important to define Activity because in Android development all the interfaces for a user of what the user sees on the screen is called an Activity and is also a class in Android development.