AndroidHire

Android Android Framework Interview Questions

Lifecycle, intents, services, and platform behavior.

50 questions in this topic · 8 sample questions below

Practice Android Framework in the quiz engine

Sample questions

  1. During a device rotation of a visible, foreground Activity, which sequence of lifecycle callbacks best describes what happens by default?

    • onPause, onStop, onDestroy on the old instance, then onCreate, onStart, onResume on a brand new instance — correct
    • Only onConfigurationChanged runs; the Activity instance is preserved
    • onPause and onResume run but the Activity is never destroyed
    • onSaveInstanceState is called but onCreate is skipped because the instance is reused

    Why: By default a configuration change destroys and recreates the Activity, so the full teardown then rebuild sequence runs. onConfigurationChanged only fires instead of recreation when you declare that config in android:configChanges, which is not the default.

  2. A user presses the Back button to finish an Activity, versus the system killing your app's process while it is in the background. Which statement is correct about onSaveInstanceState state?

    • Saved instance state is restored after process death but not after a Back-press finish, because a Back-press is an intentional finish that discards the state — correct
    • Saved instance state survives both cases identically
    • Saved instance state survives a Back-press finish but is lost on process death
    • onSaveInstanceState is never called in either scenario

    Why: A user-initiated finish (Back) is treated as permanent, so saved state is intentionally dropped, whereas process death for resource reasons preserves the saved Bundle for restoration. Claiming state survives a Back-press is the common misconception.

  3. What is the primary risk of putting a large bitmap or list into the Bundle passed to onSaveInstanceState?

    • It is silently truncated to 1MB with no error
    • It is compressed automatically so there is no practical limit
    • It only affects memory, never causing a crash
    • It can exceed the Binder transaction buffer and throw TransactionTooLargeException — correct

    Why: onSaveInstanceState data is marshalled across Binder, whose transaction buffer is limited (about 1MB shared per process), so oversized state throws TransactionTooLargeException. It is not silently truncated, which is why large objects belong in a ViewModel instead.

  4. Which mechanism survives a configuration change but is intentionally cleared when the Activity is truly finishing?

    • A static singleton holding the data
    • The onSaveInstanceState Bundle only
    • SharedPreferences written in onPause
    • A ViewModel obtained via the Activity's ViewModelStore — correct

    Why: A ViewModel is retained across configuration changes via the ViewModelStore and its onCleared runs only when the owner is permanently finishing. The onSaveInstanceState Bundle also survives rotation but is designed for small state and also survives process death, so it is a different tool.

  5. An Activity is declared with launchMode singleTask and is already at the root of a task in the background. A new Intent targets it again. What happens?

    • A second instance is created in a new task
    • A second instance is created on top of the existing one in the same task
    • The existing instance is brought forward, activities above it are cleared, and onNewIntent is delivered — correct
    • The Intent is dropped because singleTask ignores repeated launches

    Why: singleTask keeps a single instance at the task root; a re-launch clears anything above it and delivers the Intent via onNewIntent. The idea that singleTask creates a new task on every launch is a frequent misconception; it reuses the existing instance.

  6. On Android 12 and above, if you create a PendingIntent without specifying a mutability flag, what happens?

    • It defaults to mutable for backward compatibility
    • The build throws IllegalArgumentException; you must pass FLAG_IMMUTABLE or FLAG_MUTABLE explicitly — correct
    • It defaults to immutable silently with no requirement
    • It is created but cannot be used with notifications

    Why: Starting with Android 12 (API 31), constructing a PendingIntent requires explicitly passing FLAG_IMMUTABLE or FLAG_MUTABLE, otherwise it throws. Assuming it silently defaults to mutable is exactly the insecure assumption the change was made to prevent.

  7. Which pair of Activity lifecycle callbacks is correctly matched as counterparts?

    • onCreate is paired with onStop
    • onResume is paired with onDestroy
    • onStart is paired with onStop and onResume is paired with onPause — correct
    • onStart is paired with onPause

    Why: The visible lifetime is bounded by onStart/onStop and the foreground lifetime by onResume/onPause. Pairing onStart with onPause mixes the visible and foreground boundaries and is incorrect.

  8. What is the fundamental reason onDestroy cannot be relied upon for critical persistence such as saving user data?

    • onDestroy always runs but on a background thread where writes are unsafe
    • The system can kill the app's process without ever calling onDestroy, for example under memory pressure — correct
    • onDestroy is only called on configuration changes, never on finish
    • onDestroy runs before onPause so state is stale

    Why: Under memory pressure the OS may terminate the process outright, so onDestroy is not guaranteed to execute; durable saves belong in onPause or onStop. Believing onDestroy is always called before the process dies is the classic mistake.

Practice all 50 Android Framework questions

These 8 are a sample. The full Android Framework bank is scored, tracks your progress, and explains every answer.

Open the quiz

More Android interview topics