Android Components

Determine how Android resolves an implicit Intent and handle cases with zero, one, or multiple matching components.

Predict Activity lifecycle callback sequences during launch, backgrounding, configuration change, multi-window use, and process recreation.

Preserve transient Activity state across configuration changes and process death using ViewModel, saved instance state, and SavedStateHandle appropriately.

Predict task and back-stack behavior produced by launch modes, document modes, and Intent flags.

Launch external components and return typed results with the Activity Result APIs.

Configure and validate deep links and verified Android App Links.

Reproduce Activity recreation and process-death scenarios to verify lifecycle and state-restoration behavior.

Trace a View through measure, layout, draw, and input dispatch to diagnose UI behavior.

Implement a focused custom View with attribute parsing, state handling, drawing, and accessibility support.

Distinguish the Fragment lifecycle from the Fragment view lifecycle when collecting data or retaining references.

Execute Fragment transactions while predicting their effects on lifecycle state and the back stack.

Restore Fragment UI and navigation state without retaining invalid View references.

Implement type-safe navigation and argument passing between UI destinations.

Explain how composition, recomposition, snapshots, and state reads determine which composables run again.

Hoist Compose state and choose appropriately among remember, rememberSaveable, ViewModel state, and persistent state.

Use derivedStateOf and stable data structures to limit unnecessary recomposition.

Choose and implement the correct Compose side-effect API for a specified lifecycle-dependent operation.

Collect Kotlin Flow state in Compose with lifecycle awareness.

Embed Compose in a View-based screen and host an Android View inside Compose with correct lifecycle handling.

Identify avoidable recompositions and rendering bottlenecks using Compose tooling.

Choose among a started service, foreground service, bound service, WorkManager, and an exact alarm for a specified task.

Implement a foreground service with an appropriate service type, ongoing notification, and safe stop behavior.

Implement a local bound service in Kotlin and manage binding across client lifecycle transitions.

Create constrained, retryable, and chained background work with WorkManager.

Explain how background-execution limits, Doze, App Standby, and process death affect scheduled work.

Test background work under constraint changes, cancellation, retries, and simulated process termination.

Choose between manifest-declared and context-registered broadcast receivers under modern Android restrictions.

Implement a lifecycle-safe Kotlin BroadcastReceiver for a system or app-specific event.

Secure broadcasts using explicit targeting, package scoping, permissions, and exported settings.

Define a ContentProvider contract with content URIs, MIME types, columns, and operation semantics.

Implement and validate ContentProvider query, insert, update, and delete operations.

Access provider data through ContentResolver and react to changes with content observers.

Share files securely between apps using FileProvider and temporary URI permissions.

Audit manifest components for exported exposure, intent-filter risks, and least-privilege permission use.

Create PendingIntents with correct identity, mutability, update behavior, and component targeting.

Trace data and control flow across an Activity, receiver, service or worker, and provider in an integrated feature.

Diagnose component launches, tasks, services, broadcasts, and provider access using Android Studio and adb.

Design a component interaction map that remains correct under configuration changes, background limits, and process death.