Top 30 Lifecycle Interview Questions and Answers

Question 1

An Android Fragment needs a property for a complex, computationally expensive object that is only used in certain user flows. The object should be created only once. Which declaration is most appropriate?

Accepted Answer

private val myObject: MyObject by lazy { createExpensiveObject() }

Answer

private lateinit val myObject: MyObject

Answer

private lateinit var myObject: MyObject

Answer

private var myObject: MyObject? = null

Question 2

Which statement accurately describes a fundamental difference between lateinit var and val by lazy in Kotlin?

Accepted Answer

val by lazy can initialize properties of any type, including primitives, unlike lateinit var.

Answer

lateinit var guarantees initialization only when first accessed, preventing unnecessary object creation.

Answer

val by lazy requires explicit thread synchronization if accessed from multiple threads, whereas lateinit var handles it automatically.

Answer

lateinit var is used for immutable properties, while val by lazy is for mutable ones.

Question 3

What is the practical difference between onStartShouldSetResponder and onMoveShouldSetResponder?

Accepted Answer

Start claims the touch immediately on contact, while Move lets a view claim it only after the finger moves, distinguishing taps from drags

Answer

Start handles taps and Move handles keyboard events

Answer

They are aliases and behave identically

Answer

Move fires before Start to give children priority over parents

Question 4

Which approach correctly places a one-time network request and a bounds-dependent layout update in a UIViewController?

Accepted Answer

Start the request in viewDidLoad and update frames in viewDidLayoutSubviews

Answer

Start the request in viewDidLoad and update frames in viewDidLoad

Answer

Start the request in viewWillAppear and update frames in viewDidLayoutSubviews

Answer

Start the request in viewDidLayoutSubviews and update frames in viewDidLayoutSubviews

Question 5

What is the effect of calling setState inside didUpdateWidget when reacting to a parent configuration change?

Accepted Answer

It schedules a second build, making the call redundant

Answer

It forces initState to rerun before the next frame renders

Answer

The framework throws because setState is illegal during widget updates

Answer

It suppresses the build that normally follows didUpdateWidget

Question 6

When an Android Activity becomes completely invisible because the user navigated away, which lifecycle method is the most appropriate place to release expensive resources like a camera or network connection?

Accepted Answer

onStop()

Answer

onDestroy()

Answer

onPause()

Answer

onSaveInstanceState()

Question 7

Where should a scene-based iOS app save important user state to avoid data loss, and why?

Accepted Answer

In sceneDidEnterBackground, because termination from a suspended state may never call a termination method

Answer

Only in viewDidDisappear of the top view controller

Answer

In sceneDidBecomeActive, because that is when the app has the most memory

Answer

In applicationWillTerminate, since it always runs before the app closes

Question 8

When a user navigates away from an Activity, why is it better to release a resource-intensive object like a camera in onStop() instead of onPause()?

Accepted Answer

onPause() execution must be very fast because it blocks the next Activity from appearing.

Answer

Resources released in onPause() can only be reacquired by restarting the Activity with onCreate().

Answer

onStop() is the last reliable callback, as onDestroy() is not guaranteed to be called.

Answer

The system may kill the process for memory after onPause() runs, so cleanup must be fast.

Question 9

What is the primary distinction in lifecycle management between an Android Started Service and a Bound Service?

Accepted Answer

A Started Service runs independently and must call stopSelf() to terminate, while a Bound Service's lifecycle is governed by its bound clients.

Answer

Both service types are automatically destroyed by the system once all background tasks are completed.

Answer

A Started Service is destroyed when its initiating component is destroyed, while a Bound Service continues until explicitly stopped.

Answer

A Bound Service manages its own lifecycle independently, whereas a Started Service's lifecycle is tied to its bound clients.

Question 10

When using a Started Service for a long-running task like a file download, what is the most critical step to ensure the app's UI remains responsive?

Accepted Answer

Move the download logic to a background thread created within the service.

Answer

Bind a component to the service to keep it alive during the operation.

Answer

Ensure the service calls stopSelf() correctly once the download is complete.

Answer

Start it as a foreground service to give it higher system priority.

Question 11

In an iOS 13+ app using scenes, which task is appropriately handled by SceneDelegate rather than AppDelegate?

Accepted Answer

Restoring user interface state for a specific window session

Answer

Setting up a process-wide Core Data container

Answer

Handling a silent push notification to refresh shared data

Answer

Configuring the app's dependency injection container at launch

Question 12

Which statement accurately contrasts a started service with a bound service in Android?

Accepted Answer

A started service runs indefinitely until stopSelf or stopService is called, while a bound service is destroyed once all clients unbind.

Answer

A bound service is initiated with startService and returns an IBinder from onStartCommand for direct client communication.

Answer

A started service automatically stops when the component that called startService is destroyed, whereas a bound service continues running until the app process ends.

Answer

Both service types run on independent background threads by default and are interchangeable with WorkManager for long-running work.

Question 13

When an Activity is recreated after a screen rotation, what is the primary mechanism that allows it to retrieve the exact same ViewModel instance?

Accepted Answer

The new Activity instance connects to a retained ViewModelStore that holds the original ViewModel.

Answer

The ViewModel's data is automatically saved to the onSaveInstanceState Bundle and restored.

Answer

The ViewModel is tied to the Application context, so it persists as long as the app is running.

Answer

The Android system serializes the ViewModel object to disk and deserializes it for the new Activity.

Question 14

When an Activity is destroyed during a screen rotation, why does its associated ViewModel remain available to the new Activity instance?

Accepted Answer

The framework retains the ViewModelStore and reattaches it to the new Activity instance.

Answer

The Activity instance is not actually destroyed; only its views are recreated.

Answer

A static map maintained by the framework caches the ViewModel across all Activities.

Answer

The ViewModel is serialized into onSaveInstanceState and restored automatically.

Question 15

Which statement accurately describes how an Android ViewModel maintains its state during configuration changes, such as screen rotation?

Accepted Answer

The ViewModel is associated with a ViewModelStore that is retained across configuration changes, allowing the new ViewModelStoreOwner instance to retrieve the same ViewModel.

Answer

The Android system internally caches the ViewModel instance and injects it into the new Activity instance after a configuration change.

Answer

The ViewModel's data is automatically saved into the Activity's onSaveInstanceState() Bundle and then restored when the Activity is recreated.

Answer

ViewModels are designed to persist across both configuration changes and process death, making them suitable for long-term data storage.

Question 16

Which statement accurately describes a key difference between static and dynamic BroadcastReceiver registration on Android 8.0+ (API 26)?

Accepted Answer

Static receivers survive app death but are blocked from most implicit broadcasts unless exempted, while dynamic receivers tied to a context can receive implicit broadcasts but must be unregistered.

Answer

Static receivers can receive any implicit broadcast even if the app is not running, while dynamic receivers require the app process to be active.

Answer

Explicit broadcasts are blocked for static receivers on API 26+, so they must always be registered dynamically to receive intra-app messages.

Answer

Dynamic receivers continue receiving broadcasts after their context is destroyed until the system kills the process, while static receivers must be unregistered to avoid leaks.

Question 17

Which scenario best describes the appropriate use of an Android Activity?

Accepted Answer

Representing a distinct, full-screen user interface, like a login page or a settings screen.

Answer

Displaying a small pop-up menu or dialog within an existing screen.

Answer

Managing background data synchronization and network requests for the entire application.

Answer

Providing a reusable UI component that can be embedded into different parts of the application.

Question 18

When an Android app recovers from process death, what is the key difference in state restoration compared to a configuration change, and what is the recommended solution?

Accepted Answer

Process death destroys the entire application process, including standard ViewModels, making SavedStateHandle essential for transient UI state restoration.

Answer

Both scenarios primarily rely on onSaveInstanceState to store all necessary UI state, with no significant difference in ViewModel behavior.

Answer

Process death requires restoring state from persistent storage like SharedPreferences, as the savedInstanceState Bundle is too small for meaningful UI state.

Answer

Standard ViewModels automatically persist across both configuration changes and process death, as they are managed by the system.

Question 19

After an app's process is killed by the OS and the user navigates back, which statement accurately describes the state restoration process?

Accepted Answer

A new process, Activity, and ViewModel are created; the ViewModel restores its state from the SavedStateHandle.

Answer

A new Activity is created, but the existing ViewModel instance survives, preserving its state in memory.

Answer

The existing Activity instance is resumed by calling onRestart(), onStart(), and onResume(), with all state intact.

Answer

The system guarantees a call to onStop() and onDestroy(), then restores the UI state from SharedPreferences.

Question 20

A bound service has two active Activity clients. If one client undergoes a configuration change, what happens to the service?

Accepted Answer

The service remains active; the changing client unbinds and re-binds, but onCreate() is not called.

Answer

The service's onUnbind() is called for the changing client, followed by onRebind() upon re-binding.

Answer

The service is destroyed and recreated, requiring both clients to re-bind.

Answer

The service is destroyed, but only the changing client needs to re-bind to a new instance.

Question 21

Why should initialization logic that reads @Input values be placed in ngOnInit instead of the constructor?

Accepted Answer

Because input properties are guaranteed to have their initial bound values in ngOnInit but not in the constructor.

Answer

Because ngOnInit is a TypeScript compiler requirement that ensures input type safety.

Answer

Because ngOnInit executes before the constructor during component instantiation.

Answer

Because the constructor should never contain any logic whatsoever.

Question 22

Two distinct clients are bound to a Service using BIND_AUTO_CREATE. If one client calls unbindService(), what is the immediate impact on the Service?

Accepted Answer

The Service continues to run because at least one client remains bound to it.

Answer

The Service's onUnbind() method is called, followed immediately by onDestroy().

Answer

The Service enters a 'pending destruction' state until the second client unbinds.

Answer

The Service is destroyed as the system detects a change in its client count.

Question 23

What is the primary reason Android employs an Activity Lifecycle?

Accepted Answer

To provide a predictable mechanism for apps to manage resources and state during system-level interruptions.

Answer

To prevent the operating system from ever terminating background applications.

Answer

To ensure applications remain active and visible to the user at all times.

Answer

To allow developers to manually trigger screen transitions and data saving.

Question 24

An Activity binds to a service using BIND_AUTO_CREATE without startService. What happens to the service when the Activity is destroyed during rotation?

Accepted Answer

The service is destroyed if it has no other bound clients, and the new Activity must bind again

Answer

The service continues running until the new Activity instance calls unbindService on the old connection

Answer

The service survives because BIND_AUTO_CREATE persists the connection across the config change

Answer

The service is paused and resumes automatically when the new Activity restores its ServiceConnection

Question 25

To execute code every time a React Native screen becomes visible after being navigated away from, which method is most appropriate?

Accepted Answer

Subscribing to the 'focus' event using navigation.addListener

Answer

Calling a function directly within the screen's render method

Answer

Using useEffect with the screen's props as dependencies

Answer

A standard useEffect hook with an empty dependency array []

Question 26

Which statement accurately describes the Android system's involvement when a client app queries a ContentProvider?

Accepted Answer

The ActivityManagerService (AMS) resolves the URI, starts the provider's process if needed, and facilitates communication via a Binder proxy.

Answer

The client's ContentResolver directly calls the ContentProvider's query method, which executes on the provider's main thread.

Answer

The system ensures the ContentProvider is instantiated as a new object for each query to maintain isolation between client requests.

Answer

The ContentProvider's onCreate() method is invoked on the client's calling thread, and the query is handled asynchronously by the system.

Question 27

A component needs to fetch data from an API using an ID received via an @Input() property. Which lifecycle hook is the most appropriate for this initial data fetch?

Accepted Answer

The ngOnInit hook

Answer

The ngAfterViewInit hook

Answer

The ngOnChanges hook

Answer

The component's constructor

Question 28

What is the consequence of returning a cleanup function from an asynchronous onMount callback in Svelte 5?

Accepted Answer

The cleanup function will not be registered, leading to potential memory leaks upon component destruction.

Answer

The cleanup function will be correctly registered and executed when the component is destroyed.

Answer

The onMount callback will immediately throw an error, preventing component initialization.

Answer

The component will fail to render its initial DOM structure.

Question 29

Which statement accurately compares lifecycle cleanup of reactive subscriptions in Vue 3's Composition API and Svelte?

Accepted Answer

Vue's watchEffect automatically cleans up its effect on unmount, while Svelte's dollar-prefixed store syntax generates lifecycle-bound subscribe and unsubscribe calls at compile time.

Answer

Both frameworks require storing a subscription token in onMounted and calling unsubscribe in onUnmounted to avoid memory leaks.

Answer

Vue templates auto-subscribe to Observables like Angular's async pipe, while Svelte requires manual unsubscribe for any store used with the dollar prefix.

Answer

Svelte's dollar-prefixed stores must be paired with onDestroy to prevent leaks, whereas Vue's computed properties automatically teardown external Observable subscriptions.

Question 30

Which lifecycle method is the definitive place to release resources like an AnimationController when a StatefulWidget is permanently removed?

Accepted Answer

The dispose method, as it's called when the State object is permanently destroyed.

Answer

The didUpdateWidget method, to react to the widget's configuration changes.

Answer

The State object's constructor, as it's the first point of creation.

Answer

The deactivate method, as it signifies the widget's removal from the tree.