Android Developer interview questions

The four main Android application components are Activity, Service, BroadcastReceiver, and ContentProvider.

• An Activity presents an interactive screen to the user.
• A Service represents work without a user interface, subject to Android background-execution rules.
• A BroadcastReceiver reacts to broadcast messages, while a ContentProvider exposes structured data through a standard interface.

An Activity is an Android component that provides a window for a focused user interaction.

• It usually owns one screen or one major entry point in an application.
• The system creates, pauses, stops, and may destroy it as the user navigates or device conditions change.
• Its declaration in the manifest lets Android discover and launch it.

A newly opened Activity normally receives onCreate, onStart, and onResume, then onPause, onStop, and onDestroy when it closes.

• onCreate performs initial setup for that Activity instance.
• onStart makes it visible, and onResume makes it ready for foreground interaction.
• onPause and onStop remove it from active use before onDestroy performs final instance cleanup.

onCreate should establish the Activity's initial UI and instance-level setup.

• It calls super.onCreate so the framework can restore and initialize its own state.
• A View-based screen inflates or sets its layout there, while a Compose screen commonly calls setContent.
• It is also a suitable place to connect state holders and read initial Intent data without assuming the callback runs only once during the app process.

onStart means the Activity is visible, while onResume means it is in the foreground and ready for user interaction.

• An Activity can be started but not resumed when another window partly covers it.
• UI-related observers can become active according to the lifecycle state they require.
• onResume should not be treated as a one-time initialization callback because it may run many times.

onPause signals loss of foreground focus, while onStop means the Activity is no longer visible.

• onPause should complete quickly because the next Activity may be waiting to resume.
• onStop is appropriate for work that is only needed while the screen remains visible.
• Neither callback guarantees that onDestroy will follow, because the process can be terminated after the Activity stops.

Android can recreate an Activity so resources and layout can be selected for the new device configuration.

• Rotation, locale, screen size, and theme-related changes can produce a different configuration.
• The old Activity instance is destroyed and a new one is created by default.
• Durable screen data should live outside transient View objects, commonly in a ViewModel, while small restorable UI state can use saved-state mechanisms.

savedInstanceState stores a small serializable snapshot that helps restore transient UI state after Activity or Fragment recreation.

• The framework passes the saved Bundle to a newly created component when state is available.
• Values should be small because the state is transferred through a size-limited system mechanism.
• It complements rather than replaces persistent storage or a ViewModel holding richer screen data.

A Fragment is a reusable, lifecycle-aware portion of UI hosted by an Activity.

• It has its own lifecycle while depending on a host and FragmentManager.
• Multiple fragments can compose one Activity or represent destinations within it.
• A Fragment may create and destroy its View several times while the Fragment object itself remains alive.

A Fragment has a separate View lifecycle because its UI can be destroyed before the Fragment instance is removed.

• onCreate and onDestroy describe the Fragment object's lifetime.
• onCreateView through onDestroyView describe the lifetime of its current View hierarchy.
• View binding and UI observers should be cleared or scoped to the View lifecycle to avoid holding a destroyed View.

FragmentManager coordinates fragments, while a FragmentTransaction groups operations that change them.

• A transaction can add, replace, remove, show, or hide fragments in a container.
• commit schedules the grouped changes to be applied by FragmentManager.
• Adding a transaction to the back stack lets the Back action reverse it instead of immediately discarding navigation history.

An explicit Intent names the component to launch, while an implicit Intent describes an action that a matching component may handle.

• Explicit Intents are common for navigation to a known Activity within the same app.
• Implicit Intents can request capabilities such as opening a web page or sharing text.
• Android resolves an implicit Intent against registered intent filters, and there may be zero, one, or several matching apps.

An Intent can carry an action, optional data, categories, extras, flags, and an explicit component.

• The action describes the requested operation, such as viewing or sending data.
• The data URI and MIME type describe the target content.
• Extras hold small typed values in a Bundle, while flags influence launch or task behavior.

An intent filter declares which implicit Intents an Android component is prepared to receive.

• It can match an Intent's action, categories, and data characteristics.
• Filters are commonly declared in the manifest for Activities, Services, and BroadcastReceivers where supported.
• A filter exposes capability to other callers but does not itself validate whether received data is trustworthy.

A task is a user-facing sequence of Activities arranged in a back stack.

• Starting an Activity normally places a new Activity record on top of the current task.
• Pressing Back removes the top destination and reveals the previous one.
• Launch modes and Intent flags can alter this default behavior, so they should be used with a clear understanding of task semantics.

Jetpack Navigation provides a structured way to define destinations and move between them while maintaining navigation state.

• A navigation graph declares destinations, actions, and arguments.
• NavController performs navigation and manages the destination back stack.
• Integrations support Fragments, Compose, deep links, and common UI elements such as an app bar.

A deep link is a URI or request that opens a specific destination inside an application.

• It can enter the app from a browser, notification, another app, or an Android App Link.
• The destination must declare or register a matching URI pattern and receive any defined arguments.
• Navigation should construct a sensible back stack so Back behaves predictably after external entry.

A View is a basic UI element, while a ViewGroup is a View that contains and arranges child Views.

• TextView, ImageView, and Button are individual View types.
• LinearLayout, FrameLayout, and ConstraintLayout are ViewGroup types.
• A ViewGroup participates in measuring and laying out its children according to its own LayoutParams rules.

The View system measures required sizes, assigns positions, and then draws the hierarchy.

• During measure, parent constraints help each View determine its measured width and height.
• During layout, a parent assigns bounds to each child.
• During draw, Views render backgrounds, content, and child Views to the drawing surface.

These ViewGroups use different layout rules for their children.

• LinearLayout places children in one horizontal or vertical sequence.
• FrameLayout stacks children in the same area and is often used as a simple container.
• ConstraintLayout positions Views through relationships to the parent and other Views, allowing complex flat layouts.