Android Activity Lifecycle

In android, Activity represents a single screen with a user interface (UI) of an application and it will acts an entry point for users to interact with an app.

Generally, the android apps will contain multiple screens and each screen of our application will be an extension of Activity class. By using activities, we can place all our android application UI components in a single screen.

From the multiple activities in android app, one activity can be marked as a main activity and that is the first screen to appear when we launch the application. In android app each activity can start another activity to perform different actions based on our requirements.

For example, a contacts app which is having multiple activities, in that the main activity screen will show a list of contacts and from the main activity screen we can launch other activities that provide screens to perform tasks like add a new contact and search for the contacts. All these activities in the contact app are loosely bound to other activities but will work together to provide a better user experience.

Generally, in android there is a minimal dependency between the activities in an app. To use activities in application we need to register those activities information in our app’s manifest file (AndroidMainfest.xml) and need to manage activity life cycle properly.

To use activities in our application we need to define an activities with required attributes in manifest file (AndroidMainfest.xml) like as shown below



<?xml version="1.0" encoding="utf-8"?>
<manifest …..>
    <application …..>
        <activity android:name=".MainActivity" >
          …….    

          …….

        </activity>

     …….

</application>
</manifest>

The activity attribute android:name will represent the name of class and we can also add multiple attributes like icon, label, theme, permissions, etc. to an activity element based on our requirements.

In android application, activities can be implemented as a subclass of Activity class like as shown below.


public class MainActivity extends Activity {


}

Android Activity Lifecycle

Generally, the activities in our android application will go through a different stages in their life cycle. In android, Activity class have 7 callback methods like onCreate(), onStart(), onPause(), onRestart(), onResume(), onStop() and onDestroy() to describe how the activity will behave at different stages.

By using activity cal-back methods we can define how our activity can behave when the user enter or leaves our application.

Android Activity Lifecycle Callback Methods

In android, an activity goes through a series of states during its lifetime. By using callback methods we can get the activity transitions between the states. 

Android system initiates its program within an Activity starting with a call on onCreate() callback method. There is a sequence of callback methods that start up an activity and a sequence of callback methods that tear down an activity.

This section will give you detailed information about callback methods to handle activity transitions between states during the lifecycle.

onCreate()

This is the first callback method and it fires when the system creates an activity for the first time. During the activity creation, activity entered into a Created state.

If we have an application start-up logic that needs to perform only once during the life cycle of an activity, then we can write that logic in onCreate() method.

Following is the example of defining a onCreate() method in android activity.

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

onStart()

The onStart() callback method will invoke when an activity entered into Started State by completing onCreate() method. The onStart() method will make an activity visible to the user and this method execution will finish very quickly.

Following is the example of defining a onStart() method in android activity.

@Override
protected void onStart()
{
    super.onStart()
}

After completion of onStart() method execution, the activity enters into Resumed state and system invoke the onResume() method.

onResume()

When an activity entered into Resumed state, the system invokes onResume() call back method. In this state activity start interacting with the user that means user can see the functionality and designing part of an application on the single screen.

Mostly the core functionality of an app is implemented in onResume() method.

The app will stay in this Resumed state until an another activity happens to take focus away from the app like getting a phone call or screen turned off, etc.

In case if any interruption events happen in Resumed state, the activity will enter into Paused state and the system will invoke onPause() method.

After an activity returned from Paused state to Resumed state, the system again will call onResume() method due to this we need to implement onResume() method to initialize the components that we release during onPause() method

Following is the example of defining a onResume() method in android activity.

@Override
public void onResume() {
    super.onResume(); 
    if (mCamera == null) {
        initializeCamera();
    }
}

If any interruption happens in Resumed state, the activity will enter into Paused state and the system will invoke onPause() method.

onPause()

Whenever the user leaves an activity or the current activity is being Paused then the system invokes onPause() method. The onPause() method is used to pause operations like stop playing the music when the activity is in a paused state or pass an activity while switching from one app to another app because every time only one app can be focused.

Following is the example of defining a onPause() method in android activity.

@Override
public void onPause() {
    super.onPause();
  if (mCamera != null) {
        mCamera.release();
        mCamera = null;
    }
}

After completion of onPause() method execution, the next method is either onStop() or onResume() depending on what happens after an activity entered into a Paused state.

onStop()

The system will invoke onStop() callback method when an activity no longer visible to the user, the activity will enter into Stopped state. This happens due to current activity entered into Resumed state or newly launched activity covers complete screen or it’s been destroyed.

The onStop() method is useful to release all the app resources which are no longer needed to the user. 

Following is the example of defining a onStop() method in android activity.

@Override
protected void onStop()
{
    super.onStop();
}

The next callback method which raised by the system is either onRestart(), in case if the activity coming back to interact with the user or onDestroy(), in case if the activity finished running.

onRestart()

The system will invoke onRestart() method when an activity restarting itself after stopping it. The onRestart() method will restore the state of activity from the time that is being stopped.

The onRestart() callback method in android activity will always be followed by onStart() method.

onDestroy()

The system will invoke onDestroy() method before an activity is destroyed and this is the final callback method received by the android activity.

The system will invoke this onDestory() callback method either the activity is finishing or system destroying the activity to save space.

Following is the example of defining a onDestroy() method in android activity.

@Override
public void onDestroy()
{
    super.onDestroy();
}

The onDestroy() method will release all the resources which are not released by previous callback onStop() method.

Android Activity Lifecycle Diagram

Generally, in android activity class uses different callback methods like onCreate(), onStart(), onPause(), onRestart(), onResume(), onStop() and onDestroy() to go through a different stages of activity life cycle.

Following is the pictorial representation of the Android Activity Life cycle which shows how Activity will behave in different stages using callback methods.

 A simplified illustration of the activity lifecycle.

Whenever the user trying to leave an activity like switching from one app to another app, the system will use callback methods to dismantle the activity completely or partially to resume the activity from where the user left off.

Based on our requirements we can implement the activity in the android app using the callback method and it’s not necessary to use all callback methods in each android application.

Android Activity Lifecycle Example

Now we will see, how the android activity lifecycle will work with an example. Following is the example of invoking activity callback methods to see the life cycle process of activity in android application.

Here we are going to use previously created Android Hello World App example and making some modifications to MainActivity.java file like as shown below to capture Android Activity Life Cycle process.

MainActivity.java File Code

The following are the code modifications which made to include all life cycle callback methods in MainActivity.java file which is in \java\in.codingtimes.helloworld directory.

package in.codingtimes.activity_lifecycle_android;


import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

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

        Log.d("Activity Lifecycle","onCreate invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle, onCreate invoked",Toast.LENGTH_SHORT).show();
    }
    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Activity Lifecycle","onStart invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle ,onStart invoked",Toast.LENGTH_SHORT).show();
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Activity Lifecycle","onResume invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle ,onResume invoked",Toast.LENGTH_SHORT).show();
    }
    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Activity Lifecycle","onPause invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle ,onPause invoked",Toast.LENGTH_SHORT).show();
    }
    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Activity Lifecycle","onStop invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle ,onStop invoked",Toast.LENGTH_SHORT).show();
    }
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("Activity Lifecycle","onRestart invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle ,onRestart invoked",Toast.LENGTH_SHORT).show();
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Activity Lifecycle","onDestroy invoked");
        Toast.makeText(getApplicationContext(),"Activity Lifecycle ,onDestroy invoked",Toast.LENGTH_SHORT).show();
    }
}

If you observe above code we defined a statement like “setContentView(R.layout.activity_main);” which will help to load all UI components defined in activity_main.xml file and used Log.d() method to generate log messages.

In our application we can have more than one activity file and we need to declare all the activities in the AndroidManifest.xml file. In the manifest XML file, by using MAIN action and LAUNCHER category attributes in intent filters (<intent-filter>) we can mention the main activity that opens when the user initially launches our app with the launcher icon. In case if we didn’t mention the MAIN action, then the system will decide which activity needs to start and if we didn’t add the LAUNCHER category for the main activity, our app icon will not appear in the home screen’s list of apps.

The code of AndroidManifest.xml file will be like as shown below.



<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="in.codingtimes.helloworld" >

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".MainActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Activity state and ejection from memory

The system kills processes when it needs to free up RAM; the likelihood of the system killing a given process depends on the state of the process at the time. Process state, in turn, depends on the state of the activity running in the process. Table 1 shows the correlation among process state, activity state, and likelihood of the system’s killing the process.

Likelihood of being killedProcess stateActivity state
LeastForeground (having or about to get focus)Created
Started
Resumed
MoreBackground (lost focus)Paused
MostBackground (not visible)Stopped
EmptyDestroyed

Table 1. Relationship between process lifecycle and activity state

The system never kills an activity directly to free up memory. Instead, it kills the process in which the activity runs, destroying not only the activity but everything else running in the process, as well.

That’s it!
You have successfully completed the post. Do Share : )

Peace Out!

Source Code – https://github.com/Adityaraj-30/Activity_Lifecycle_Android.git

Also Read – Android Application Components


Check Out Deals on -> Amazon , Flipkart , Myntra , Adidas , Apple TV , Boat , Canva , Beardo , Coursera , Cleartrip , Fiverr , MamaEarth , Swiggy, KFC


Leave a Reply

Your email address will not be published.