AAD sample questions

Question 1

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

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 3

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 4

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 5

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 6

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

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.

Question 8

When making a custom Jetpack Compose component accessible, which of the following `semantics` properties are most important for screen readers like TalkBack to properly describe the component's purpose and state? (Select TWO)

Accepted Answer

`contentDescription`

Accepted Answer

`stateDescription`

Answer

`testTag`

Answer

`isRoot`

Question 9

A developer is using the Layout Inspector in Android Studio to debug a Jetpack Compose UI. They want to understand why a specific composable is recomposing frequently. Which feature of the Layout Inspector is specifically designed for this purpose?

Accepted Answer

The Recomposition Counts, which highlights composables and displays how many times they have recomposed and skipped.

Answer

The Component Tree view, which shows the hierarchy of composables.

Answer

The 3D Mode, which visualizes the layout layers in three dimensions.

Answer

The Attributes pane, which lists all the parameters and modifiers for a selected composable.

Question 10

To define a test method in a local unit test using JUnit 4, which annotation must be placed directly before the function declaration?

Accepted Answer

`@Test`

Answer

`@Before`

Answer

`@Rule`

Answer

`@RunWith`

AAD Sample Questions & Answers

Ready for the real thing?

AAD Sample Questions & Answers

Related practice tests

Ready for the real thing?