Describe the Android Activity lifecycle when navigating away and back

What's really being asked

This isn't a test of rote memorization; it's a fundamental test of your ability to write safe, resource-efficient Android applications. The interviewer wants to know if you understand the state machine an Activity moves through and, more importantly, how to map application logic (like starting/stopping a network request or video player) to the correct lifecycle callback to prevent memory leaks, crashes, and poor user experience.

The full answer

An excellent answer describes the sequence and the purpose. First, when a user navigates away, the system calls onPause() followed by onStop(). Second, when the user returns to the activity, the sequence is onRestart(), then onStart(), and finally onResume(). Third, you must explain the distinction: onPause() is called when the activity is partially obscured (like by a dialog) and must be extremely lightweight. onStop() is called when the activity is no longer visible to the user. Fourth, you should describe what work belongs where: onPause() is for pausing animations or video. onStop() is for releasing expensive resources like a camera or network connections. onResume() is where you would re-acquire those resources.

The mistakes people make

A common mistake is forgetting onRestart() and incorrectly stating the sequence is onStop() -> onStart(). Another red flag is confusing the roles of onPause() and onStop(). Placing a heavy operation like saving to a database or releasing the camera in onPause() is incorrect; this method needs to execute very quickly (under a few milliseconds) because it blocks the UI thread and delays the appearance of the next screen. Finally, failing to mention state persistence via onSaveInstanceState() in the context of onStop() suggests an incomplete understanding of how to handle process death.

What usually comes next

Expect questions like: "Where does onSaveInstanceState() get called in this flow, and how does it differ from persisting data in onStop()?" or "What happens if the system kills your app's process while it's in the background?" or "How does this lifecycle change for a configuration change, like screen rotation?" or "How do Jetpack Lifecycle-Aware Components simplify this management?"

A concrete example

In a video player app, when a user navigates away: onPause() is called, and you should pause the video playback. Then onStop() is called; here you could release the media player and decoder resources entirely to free up memory. When the user returns: onRestart() is called, followed by onStart(), where you might re-initialize the media player. Finally, in onResume(), you would resume video playback from its last position, which you should have saved in onSaveInstanceState().