AAD sample questions

Question 1

A junior developer is building a Jetpack Compose screen that displays a list of user profiles. They've noticed that whenever a single profile's 'like' status changes, the entire list recomposes, causing performance issues. The senior developer suggests using 'state hoisting'. What is the primary goal of state hoisting in this context?

Accepted Answer

To move state from a composable to its caller, making the composable stateless and reusable, thus allowing more granular control over recomposition.

Answer

To store the UI state directly within the Android ViewModel, bypassing the need for `remember` and `mutableStateOf` in the composable.

Answer

To use the `derivedStateOf` function to compute a new state value only when its dependencies change, thus avoiding recomposition.

Answer

To encapsulate the state within the child composable using `rememberSaveable` to ensure it survives process death and configuration changes.

Question 2

An application uses a Room database with a DAO that returns a `Flow >` to observe data changes. The UI layer collects this flow, but under heavy database write loads, the UI freezes because it's receiving updates too frequently. Which Flow operator is the most appropriate solution to apply before collecting the flow in the UI layer to mitigate this issue without losing the final state?

Accepted Answer

`conflate()`

Answer

`debounce(500)`

Answer

`sample(500)`

Answer

`distinctUntilChanged()`

Question 3

A developer needs to schedule a background task using WorkManager that should only run when the device has a certain level of battery and is connected to a Wi-Fi network. Which of the following constraints should be applied to the `WorkRequest`? (Select TWO)

Accepted Answer

`setRequiredNetworkType(NetworkType.UNMETERED)`

Accepted Answer

`setRequiresBatteryNotLow(true)`

Answer

`setRequiresCharging(true)`

Answer

`setRequiredNetworkType(NetworkType.CONNECTED)`

Answer

`setDeviceIdle(true)`

Question 4

When writing a unit test for a `ViewModel` that uses `viewModelScope` to launch coroutines, what is the modern, recommended approach to manage the `Dispatchers.Main` dispatcher and control coroutine execution within a JUnit test?

Accepted Answer

Create a JUnit `@Rule` that uses `Dispatchers.setMain(testDispatcher)` and `Dispatchers.resetMain()` with a `StandardTestDispatcher`, and wrap the test body in `runTest`.

Answer

Use a `TestCoroutineRule` that utilizes `TestCoroutineDispatcher` and `TestCoroutineScope`, and call `runBlockingTest` in the test method.

Answer

Inject `Dispatchers.IO` into the ViewModel and use `runBlocking` to execute the test logic on the IO dispatcher.

Answer

Use `GlobalScope.launch` within the test to run assertions on a background thread, avoiding conflicts with the main thread.

Question 5

To clear all data for a specific application package during development, a developer can use the Android Debug Bridge (adb). The command to achieve this is: `adb shell pm clear ______`.

Accepted Answer

com.example.myapp

Answer

MyApp

Answer

--all

Answer

cache

Question 6

**Company Background:**
`FitLife` is a fitness tracking company modernizing its Android application. The current app was built five years ago using XML layouts and the traditional View system. The UI is inconsistent, slow to render complex screens, and difficult to maintain due to deeply nested `LinearLayouts` and `RelativeLayouts` inside a `ScrollView`.

**Current Situation:**
The main dashboard screen is particularly problematic. It displays user stats, a list of recent workouts, and daily challenges. All this data comes from a `DashboardViewModel` which exposes several `LiveData` objects. The XML for this screen is over 800 lines long.

**Requirements:**
The CTO has mandated a full migration of the dashboard screen to Jetpack Compose to improve performance and maintainability. The new implementation must:
1. Be built entirely with declarative UI components.
2. Observe the existing `LiveData` objects from the `DashboardViewModel` in a lifecycle-aware manner.
3. Replace the `RecyclerView` for recent workouts with a lazy-loading list in Compose.
4. Ensure the new UI is themable and supports Material 3 design principles.

Which of the following approaches is the most effective and idiomatic way to implement the new Jetpack Compose dashboard screen based on the requirements?
```mermaid
flowchart TD
subgraph ViewModel
A[LiveData ]
B[LiveData >]
C[LiveData ]
end
subgraph Compose UI
D{DashboardScreen}
E[StatsCard]
F[WorkoutList]
G[ChallengeBanner]
end
ViewModel --> D
D --> E
D --> F
D --> G
```

Accepted Answer

Create a `DashboardScreen` composable. Use `liveData.observeAsState()` to convert each `LiveData` object into a Compose `State`. Use a `LazyColumn` to display the list of workouts. Wrap the entire screen in the app's `MaterialTheme` composable.

Answer

Use an `AndroidView` composable to embed the old XML layout inside a Compose UI. In the `factory` lambda of `AndroidView`, inflate the XML and manually observe the `LiveData` to update the Views.

Answer

Convert all `LiveData` objects in the `DashboardViewModel` to Kotlin `StateFlow`. In the `DashboardScreen` composable, collect the flows using `collectAsState()` and display the data in a `Column` with `verticalScroll` modifier.

Answer

In the `DashboardScreen` composable, launch a coroutine using `LaunchedEffect` to collect the `LiveData` values. Use `mutableStateOf` to hold the values locally. For the list, iterate through the workout list and create a `Row` for each item inside a `LazyColumn`.

Question 7

True or False: Jetpack DataStore is a direct, drop-in replacement for SharedPreferences and uses the same synchronous, file-based I/O API on the main thread.

Accepted Answer

False

Answer

True

Question 8

On Android 14 (API 34), an app that needs to perform a long-running task like a data sync must declare a foreground service. What is the critical requirement that the app must fulfill when calling `startForeground()` for a service related to data synchronization?

Accepted Answer

A valid foreground service type, such as `FOREGROUND_SERVICE_TYPE_DATA_SYNC`, must be included in the service's manifest declaration.

Answer

The service must be declared with `android:exported="true"` in the manifest.

Answer

The app must hold the `WAKE_LOCK` permission to ensure the CPU remains active.

Answer

The service must be started using a `PendingIntent` from a notification action.

Question 9

In an Espresso UI test, the app performs a network request that takes an unpredictable amount of time to complete before updating a `TextView`. The test intermittently fails with an `NoMatchingViewException` because the assertion runs before the `TextView` is updated. What is the most robust and recommended way to make Espresso wait for this asynchronous operation to complete?

Accepted Answer

Implement and register an `IdlingResource` that monitors the network request's state and tells Espresso to wait until the operation is complete.

Answer

Add a `Thread.sleep(5000)` call in the test before the assertion to give the network request enough time to finish.

Answer

Wrap the Espresso assertion in a `try-catch` block inside a `while` loop that retries the check every 500 milliseconds until it succeeds or times out.

Answer

Use `UIAutomator` instead of Espresso, as it has built-in automatic waits for UI elements to appear.

Question 10

In Jetpack Compose, a developer needs to display a potentially very long, vertically scrolling list of items. To ensure good performance, only the items visible on screen should be composed and rendered. Which composable should be used?

Accepted Answer

A `LazyColumn` composable.

Answer

A `Column` composable with a `Modifier.verticalScroll(rememberScrollState())`.

Answer

A `FlowRow` composable.

Answer

A `BoxWithConstraints` composable.

Top vendors

Top exams

Free AAD sample questions