Android Studio - 8 - Activity Lifecycle in Android

Start MCQ

The Activity lifecycle is a fundamental concept in Android app development. It defines the series of states and transitions that an Android activity goes through during its existence. Understanding the activity lifecycle is crucial for managing the behavior and user experience of your Android applications. In this guide, we’ll explore the Android Activity lifecycle, including its key methods and the events associated with each state.

The Android Activity Lifecycle

An Android activity, which represents a single screen with a user interface, goes through several states as it’s created, started, resumed, paused, stopped, and destroyed. These states are managed by the Android operating system and can be influenced by user interactions and system events. The key states in the Activity lifecycle are:

1. Created (onCreate)

The onCreate method is called when the activity is first created. This is where you typically perform one-time initialization, such as setting up UI elements, binding data, and initializing variables. You must call super.onCreate(savedInstanceState) to ensure the activity is properly initialized.

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Initialize UI and variables
}

2. Started (onStart)

The onStart method is called when the activity becomes visible to the user but is not yet interactive. You can perform tasks like registering broadcast receivers or preparing UI elements. This is a good place to start animations or other visual effects.

@Override
protected void onStart() {
    super.onStart();
    // Perform tasks when activity is started
}

3. Resumed (onResume)

The onResume method is called when the activity is in the foreground and ready for user interaction. It’s the ideal place to start components that should run while the activity is active, such as location updates or media playback.

@Override
protected void onResume() {
    super.onResume();
    // Start components that should run when activity is in the foreground
}

4. Paused (onPause)

The onPause method is called when the activity loses focus but is still partially visible. This can occur when another activity is in the foreground but doesn’t completely cover the current activity. You should pause or release resources that are not needed when the activity is not in the foreground.

@Override
protected void onPause() {
    super.onPause();
    // Pause or release resources not needed when activity is in the background
}

5. Stopped (onStop)

The onStop method is called when the activity is no longer visible to the user. This typically happens when the user navigates to another activity or the app goes into the background. In this state, you can release resources and unregister broadcast receivers.

@Override
protected void onStop() {
    super.onStop();
    // Release resources and unregister receivers when activity is stopped
}

6. Destroyed (onDestroy)

The onDestroy method is called when the activity is being destroyed either due to a user action (e.g., pressing the back button) or because the system needs to free up memory. You should release all resources and perform cleanup tasks in this method.

@Override
protected void onDestroy() {
super.onDestroy();
// Release resources and perform cleanup tasks when activity is destroyed
}

Handling Configuration Changes

Android can destroy and recreate activities during certain configuration changes, such as screen rotation or changing the device’s language. To handle these events and preserve the activity’s state, you can override the onSaveInstanceState method to save important data and restore it in the onCreate method:

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    // Save important data to the bundle
    outState.putString("key", "value");
}

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

    if (savedInstanceState != null) {
        // Restore saved data from the bundle
        String value = savedInstanceState.getString("key");
    }
}

Handling Explicit Activity Transitions

In addition to the lifecycle methods, you can explicitly transition between activities using intents. For example, to start a new activity:

Intent intent = new Intent(this, SecondActivity.class); startActivity(intent);

You can also pass data between activities using extras in the intent:

Intent intent = new Intent(this, SecondActivity.class); intent.putExtra("key", "value"); startActivity(intent);

In the receiving activity, you can retrieve the data:

Intent intent = getIntent(); String value = intent.getStringExtra("key");

Conclusion

Understanding the Android Activity lifecycle is essential for developing robust and responsive Android applications. By implementing the appropriate lifecycle methods and managing state changes, you can create apps that provide a smooth user experience, handle configuration changes gracefully, and efficiently manage system resources. Additionally, the ability to transition between activities using intents gives you the flexibility to design complex and interactive app workflows.

Android Studio – 8 – Activity Lifecycle in Android