AAD sample questions

Question 1

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 2

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 3

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 4

**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 5

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 6

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 7

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 8

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.

Question 9

**Company Background:**
`FieldAgentPro` is an enterprise application used by technicians for on-site job management. A core requirement is robust offline capability, as technicians often work in areas with poor or no internet connectivity. All job data, including customer details, work orders, and inventory parts, must be available offline.

**Current Situation:**
The development team is designing the data layer for the app. They have decided to use Room for local persistence and Retrofit for network communication with the backend API. The architecture must follow the 'single source of truth' principle, where the UI only observes data from the local Room database.

**Requirements:**
1. The app must fetch data from the network and store it in the Room database when online.
2. When offline, the app must seamlessly serve data from the Room database.
3. The UI should be updated automatically whenever the local data changes (either from a network sync or local modification).
4. The data layer must abstract the origin of the data (network vs. local) from the ViewModel and UI.
5. The design should be efficient, avoiding unnecessary network calls if the local data is fresh.

Which of the following data layer designs best satisfies all requirements for this offline-first application?
```mermaid
erDiagram
VIEW_MODEL ||--|{ REPOSITORY : uses
REPOSITORY ||--|{ API_SERVICE : fetches_from
REPOSITORY ||--|{ ROOM_DAO : accesses

API_SERVICE {
string type "(Retrofit)"
}
ROOM_DAO {
string type "(Room)"
}
```

Accepted Answer

Implement a Repository that exposes a `Flow ` from the Room DAO. The function to get data first checks for network connectivity. If online, it fetches from the API, saves the result to Room, and the Flow automatically emits the update. If offline, it does nothing, and the Flow continues to show the existing cached data.

Answer

The ViewModel directly calls the Retrofit service. If the call succeeds, it shows the data and saves it to Room. If it fails due to no connectivity, the ViewModel then makes a second call to the Room DAO to fetch the cached data.

Answer

Create two separate functions in the ViewModel: `fetchOnlineData()` and `fetchOfflineData()`. The UI layer is responsible for checking network status and calling the appropriate function based on the result.

Answer

Use a Paging 3 `RemoteMediator` to handle fetching from the network and saving to Room. The ViewModel collects the `PagingData` Flow directly from the Pager.

Question 10

To handle a deep link URI such as `https://example.com/products/123`, which element must be correctly configured inside the ` ` tag in the `AndroidManifest.xml` when using the Navigation Component?

Accepted Answer

An ` ` with a ` ` element specifying the URI scheme, host, and path pattern, along with a ` ` tag inside the activity.

Answer

A ` ` tag pointing to the navigation graph resource.

Answer

The `android:pathPattern` attribute directly on the ` ` tag.

Answer

A ` ` tag directly inside the ` ` manifest entry.

Free AAD sample questions