Android Activity Lifecycle

# CHAPTER 9

Android Activity Lifecycle #

1. Introduction #

2. Learning Objectives #

• Define the six core Activity Lifecycle callbacks.

• Understand exactly when the Android OS triggers onCreate vs onResume.

• Properly handle backgrounding an app utilizing onPause and onStop.

• Release critical resources to prevent memory leaks during onDestroy.

• Architect apps that survive sudden screen rotations.

3. The Lifecycle Pyramid #

1. 1. onCreate(): The Birth.

1. 2. onStart(): Becoming Visible.

1. 3. onResume(): The Foreground (User is actively tapping it).

1. 4. onPause(): Losing Focus.

1. 5. onStop(): Hidden in the Background.

1. 6. onDestroy(): The Death.

4. Birth and Foreground (onCreate, onStart, onResume) #

1. onCreate() This fires exactly ONCE when the screen is created in memory. *What to do here:* Set the XML layout (setContentView), initialize variables, and bind buttons. Do NOT do heavy loading here, or the app will feel slow to open.

2. onStart() The screen is now physically visible to the user, but they cannot tap on it yet (it might be behind a transparent popup).

3. onResume() The screen is fully loaded, in the foreground, and the user is actively interacting with it. *What to do here:* Start camera previews, begin complex animations, or refresh real-time GPS data.

5. Backgrounding and Death (onPause, onStop, onDestroy) #

4. onPause() Fires immediately when the app loses "focus". Maybe a phone call came in, or the user pressed the Home button. The app is partially visible but not active. *What to do here:* Pause video playback, save draft text, and pause heavy animations.

5. onStop() Fires when the Activity is no longer visible on the screen at all (the user went back to the home screen). *What to do here:* Stop fetching GPS coordinates! Disconnect from real-time database listeners to save battery!

6. onDestroy() Fires when the OS completely kills the app from memory (or the user physically swipes it away in the multi-tasking menu). *What to do here:* Clean up any massive background threads or memory heavy processes.

6. Code Implementation #

package com.example.lifecycleapp

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

    private val TAG = "LifecycleDemo"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d(TAG, "onCreate: The screen is born!")
    }

    override fun onStart() {
        super.onStart()
        Log.d(TAG, "onStart: The screen is visible!")
    }

    override fun onResume() {
        super.onResume()
        Log.d(TAG, "onResume: The user is interacting!")
        // Start playing video!
    }

    override fun onPause() {
        super.onPause()
        Log.d(TAG, "onPause: The screen lost focus.")
        // Pause the video!
    }

    override fun onStop() {
        super.onStop()
        Log.d(TAG, "onStop: The screen is completely hidden.")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(TAG, "onDestroy: The screen was destroyed by the OS.")
    }
}

*(By opening Logcat at the bottom of Android Studio, you can watch these messages print in real-time as you minimize and reopen the app!)*

7. The Screen Rotation Trap #

8. Common Mistakes #

• Doing too much in onPause: The onPause execution time is incredibly short (milliseconds). If you try to execute a massive database save operation inside onPause, the OS will likely kill your app before it finishes, resulting in data loss. Save heavy data operations for onStop or background threads.

• Forgetting super.onX(): When you override a lifecycle method, you MUST call super.onCreate() or super.onPause() on the very first line of the block. If you delete the super call, the app will instantly crash with a SuperNotCalledException.

9. Best Practices #

• Symmetry: A good rule of thumb is symmetry. If you allocate a resource in onStart (like a GPS listener), you should cleanly destroy it in the matching onStop. If you initialize a camera in onResume, shut it down in onPause.

10. Exercises #

1. 1. Copy the code from Section 6 into a blank Android project.

1. 2. Run the app on an emulator. Click the "Home" button on the emulator to minimize the app. Look at the Logcat console and note which three callbacks fired in order.

11. Coding Challenges #

12. MCQ Quiz with Answers #

13. Interview Questions #

• Q: Explain the strict architectural difference between onPause() and onStop(). In what specific visual scenario would onPause() fire, but onStop() would NOT fire? (Hint: Think about popups).

• Q: Why is executing heavy network operations directly within onCreate() considered an anti-pattern? How does it affect the perceived launch performance of the application?

• Q: Describe the concept of Lifecycle Symmetry. If a developer registers a BroadcastReceiver in onResume(), in which specific callback must they unregister it to prevent a memory leak?

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #