Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.
AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Google
Exam Format
Registration
Validity
Skills this practice test covers
- Schedule background work with WorkManager and show messages with Toasts, Snackbars and notifications.
- Build screens with ConstraintLayout, a custom View and a RecyclerView list.
- Store data with Room entities and a DAO, and observe changes with LiveData.
- Keep user settings in preferences and change the app's behavior from them.
- Find faults with the System Log, Logcat and breakpoints in Android Studio.
- Write local JUnit tests and Espresso UI tests for an Android app.
Explore related topics
AAD exam content
5 domains · 57 topics · 173 of 181 questions sorted by domain
Android Core28 questions
This domain covers how an Android app is put together and run. Candidates explain the system architecture and the building blocks of an app, show messages to users, localize an app, and schedule background work.
Skills tested
- Describe the Android system architecture and the basic building blocks of an app.
- Show messages with a Toast, a Snackbar or a notification.
- Localize an app with resources for other languages.
- Schedule background tasks with WorkManager within the background execution limits.
Questions by topic
- WorkManager Constraints3
- Foreground Services4
- Broadcast Receivers4
- Background Processing Strategy2
- Runtime Permissions2
- Content Providers2
- Background Execution Limits3
- App Component Security4
- Security2
- StateFlow vs SharedFlow1
- Coroutines and Threading1
User Interface49 questions
This domain is about screens. Candidates follow the activity lifecycle, build layouts, write a custom View, apply a theme and accessibility features, show lists, and add navigation.
Skills tested
- Handle the activity lifecycle and build a layout with ConstraintLayout.
- Create a custom View class, add accessibility hooks, and apply a custom app theme.
- Display items in a RecyclerView and bind local data to it with the Paging library.
- Implement menu-based navigation and drawer navigation.
Questions by topic
- Jetpack Compose State Management6
- Jetpack Compose Migration3
- Jetpack Compose Lists3
- Navigation Component Deep Links3
- Jetpack Compose Accessibility3
- Jetpack Compose Side Effects4
- Jetpack Compose Custom Layouts6
- Jetpack Compose Modifiers3
- RecyclerView Performance6
- Material 3 Theming3
- Adaptive UI with Jetpack Compose3
- Custom View Performance3
- Jetpack Compose Layouts3
Data Management34 questions
This domain covers how an app stores and serves its data. Candidates define a Room database, observe changes with LiveData, route data through a repository, and keep user settings in preferences.
Skills tested
- Define Room entities and access them through a data access object (DAO).
- Observe and respond to changing data with LiveData.
- Use a repository to keep data operations in one place.
- Read raw resources and asset files, and save preferences that change how the app behaves.
Questions by topic
- Kotlin Flow with Room3
- DataStore vs SharedPreferences3
- Offline-First Architecture2
- Room Database Migration4
- Room Database Entities4
- Proto DataStore3
- Room Database Relationships3
- Paging 3 Library2
- Room OnConflictStrategy3
- StateFlow vs SharedFlow2
- Room Full-Text Search3
- Content Providers1
- Security1
Debugging26 questions
This domain asks how to find and fix faults in Android Studio. Candidates write debug output to the System Log, set breakpoints, and repair problems in an app's behavior and usability.
Skills tested
- Write debug output to the System Log and read it in Logcat.
- Set breakpoints and step through code in the Android Studio debugger.
- Fix faults in an app's functional behavior and usability.
- Find performance problems and memory leaks with the profiling tools.
Questions by topic
- Android Debug Bridge (adb)3
- Layout Inspector for Compose2
- ANR Troubleshooting3
- Logcat Usage3
- APK Analysis4
- StrictMode4
- CPU Profiler3
- Android Studio Debugger2
- Memory Leak Analysis1
- Memory Profiler1
Testing36 questions
This domain covers automated tests. Candidates explain the fundamentals of testing, write local JUnit tests, and write UI tests with the Espresso framework.
Skills tested
- Write local JUnit tests for the logic of an app.
- Write Espresso tests that drive the user interface and check the result.
- Decide what to cover with local tests and what with automated UI tests.
Questions by topic
- Testing Coroutines6
- Espresso UI Testing4
- JUnit Annotations2
- Testing Jetpack Compose4
- Testing Kotlin Flow3
- Testing Strategy3
- Robolectric Framework4
- Test Source Sets5
- Testing Fundamentals2
- ViewModel Testing3
Requirements
- No formal prerequisites.
- Recommended: at least six months of Android development in Kotlin or Java.
- Recommended: familiarity with Android Studio and with the components of an Android app.
About the AAD exam
AAD is Google's entry-level certification for developers who build Android apps in Kotlin or Java. The exam is performance-based: candidates complete coding tasks in an Android Studio project, and an exit interview follows. Its five areas cover Android core features, the user interface, data management, debugging and testing. Passing earns the Associate Android Developer certification, which stays valid for three years.
User Interface has the most questions in the PlanetCert practice test. The test also covers newer tools that the published study guide does not name, such as Jetpack Compose, Kotlin Flow and DataStore. The real exam asks for working code, so the explanations are best read with Android Studio open. Study Mode suits the lifecycle and Room questions, where the order of calls matters. Brainy AI Assistant can explain when a lifecycle callback runs, or how a DAO query returns LiveData.
How to earn the certification
- Earns
- Associate Android DeveloperAssociate
The certification stays valid for three years.
- After
- GCP-PCD Google Cloud Professional Cloud Developer
Google Cloud's professional exam for developers who build and deploy applications on Google Cloud.
- GCP-ACE Google Cloud Associate Cloud Engineer
Google Cloud's associate exam for deploying and running workloads on Google Cloud.
- GCP-PCD Google Cloud Professional Cloud Developer
How to prepare for AAD
- 1
Confirm that registration is open
Before planning study time, check Google's certification page to confirm that AAD registrations are open. The exam is a coding project, so plan for practice in Android Studio, not only reading.
- 2
Build one app across all five areas
Write a small Kotlin app with a RecyclerView list, a Room database behind a repository, LiveData updates, a settings screen and a WorkManager job. Each piece matches a topic in the study guide.
- 3
Break the app, then debug it
Add faults on purpose, then find them with Logcat output and breakpoints. Debugging is an area of its own, so practise until each tool feels routine.
- 4
Add JUnit and Espresso tests
Write local JUnit tests for the repository and an Espresso test for the main screen. Run both from Android Studio and fix each failure.
- 5
Check the concepts with practice questions
Take the AAD practice test in Study Mode to check the ideas behind each coding task, then sit a Timed Mode run. Ask Brainy AI Assistant about any lifecycle or Room answer that went wrong.
Start a timed AADrun
Who AAD is for
- Entry-level Android developers who want proof that they can build a working app.
- Students who are aiming for a first job in Android development.
- Web and back-end developers who are moving into mobile development.
Typical job titles: Android developer · Mobile app developer · Junior software engineer · Kotlin developer
AAD glossary
17 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Activity lifecycle
- The states an activity passes through, such as created, started, resumed and stopped, with a callback for each.
- Breakpoints
- Markers in code where the debugger pauses the app, so the values of variables can be inspected.
- ConstraintLayout
- A layout that places each view by constraints to other views or to its parent, so layouts stay flat.
- Content descriptions
- Text labels on views that screen readers read aloud, so the app works for users who cannot see the screen.
- Data access object (DAO)
- An interface that declares the queries and updates an app can run on its Room database.
- Espresso
- Android's framework for UI tests that click, type and check views inside a running app.
- JUnit
- The test framework for local unit tests, which run on the development computer instead of on a device.
- LiveData
- An observable data holder that tells the user interface when data changes and follows the activity lifecycle.
- Logcat
- The Android Studio window that shows the System Log, including the debug messages an app writes.
- Paging library
- A Jetpack library that loads a large data set in small pages as the user scrolls.
- RecyclerView
- A view that shows long lists efficiently by reusing the item views that scroll off the screen.
- Repository
- A class that hides where data comes from, such as a database or a network, behind one simple interface.
- Room
- A Jetpack library that stores app data in a local SQLite database through annotated Kotlin or Java classes.
- SharedPreferences
- Simple key-value storage for small values, such as user settings.
- Snackbar
- A short message at the bottom of the screen that can offer one action, such as Undo.
- Toast
- A short popup message that appears for a moment and then disappears on its own.
- WorkManager
- The Jetpack library for background work that must still run if the user leaves the app or the device restarts.