What is an Activity and its lifecycle?

Question

Accepted Answer

An **Activity** represents a single screen with a user interface — a fundamental Android component. Its **lifecycle** (the sequence of states and callbacks as it's created, shown, hidden, and destroyed) is crucial to understand for managing resources and state correctly.

## What an Activity is

```text
An ACTIVITY = one screen of the app (a UI the user interacts with):
  → an app is typically several activities (a login screen, a home screen, etc.)
  → the OS manages activities and calls LIFECYCLE methods as their state changes
```

## The Activity lifecycle

```text
Key lifecycle callbacks (the OS calls these as the activity's state changes):
  onCreate()  → activity is being CREATED → initialize UI, set up (called once)
  onStart()   → becoming VISIBLE to the user
  onResume()  → now in the FOREGROUND, interactive (user can interact)
  onPause()   → losing focus (another activity coming in front) → pause/save lightly
  onStop()    → no longer VISIBLE → release resources, stop heavy work
  onDestroy() → being DESTROYED → final cleanup
→ Flow: onCreate → onStart → onResume → [running] → onPause → onStop → onDestroy
```

## Why the lifecycle matters

```text
The activity's state changes (user navigates away, a call comes in, rotation, etc.):
  → MANAGE RESOURCES — acquire in onResume/onStart, release in onPause/onStop
    (e.g. start/stop a camera, location updates, sensors)
  → SAVE STATE — onPause/onSaveInstanceState before the activity may be destroyed
  → CONFIGURATION CHANGES (e.g. rotation) DESTROY and recreate the activity → must
    handle state restoration (a common source of bugs)
→ Mismanaging the lifecycle → leaks, crashes, lost state.
```

## Why it matters

Understanding the Activity and its lifecycle is fundamental to Android development because activities are core components and managing their lifecycle correctly is essential for correct apps, so it's must-know foundational knowledge.

An **Activity** (a single screen with a UI) is one of Android's fundamental building blocks, and apps are composed of activities representing different screens.

Understanding the **lifecycle** — the sequence of callbacks (onCreate for initialization, onStart/onResume as it becomes visible and interactive, onPause/onStop as it loses focus and visibility, onDestroy for cleanup) that the OS calls as the activity's state changes — is crucial because it governs when to do what.

Understanding **why the lifecycle matters** is the key practical knowledge: you must **manage resources** appropriately (acquiring resources like the camera, location updates, or sensors when the activity is active and releasing them when it's not, to avoid wasting resources and battery), **save and restore state** (since the activity may be destroyed), and crucially handle **configuration changes** (like screen rotation, which **destroys and recreates the activity** — a common source of bugs where state is lost if not handled).

Mismanaging the lifecycle leads to real problems: memory leaks (holding resources when stopped), crashes, and lost state (especially on rotation).

Since activities are fundamental Android components and correctly managing their lifecycle (resource management, state saving, handling configuration changes) is essential for building correct, robust apps that don't leak, crash, or lose state, understanding the Activity and its lifecycle is essential, foundational Android knowledge — one of the most important concepts in Android development, necessary for writing apps that behave correctly across the state changes (navigation, rotation, interruptions) that constantly occur, and a frequent source of bugs that proper lifecycle understanding prevents.