Mobile App Development Native Android Development Syllabus

Native Android Development syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Native Android Development in Mobile App Development, not a summary of it.

1. 1

   Android Studio and Project Setup

   4 topics

   • Android Studio and Gradle
   • Project Structure and Manifest
   • Emulators and Physical Devices
   • Resources and Configuration Qualifiers
2. 2

   Jetpack Compose

   4 topics

   • Composable Functions and Modifiers
   • State and Recomposition
   • Navigation Compose
   • Theming and Material 3
3. 3

   Android Views and UI

   3 topics

   • XML Layouts and View Binding
   • RecyclerView and Adapters
   • ConstraintLayout
4. 4

   Android Architecture Components

   4 topics

   • ViewModel and LiveData
   • Lifecycle-Aware Components
   • WorkManager and Background Tasks
   • Navigation Component
5. 5

   Concurrency and Networking

   3 topics

   • Kotlin Coroutines and Flow
   • Retrofit and OkHttp
   • JSON Serialization (Moshi/Gson)
6. 6

   Data Persistence on Android

   3 topics

   • SharedPreferences and DataStore
   • Room Database
   • File Storage and Scoped Storage
7. 7

   Android Platform Services

   4 topics

   • Firebase Cloud Messaging
   • Location and Maps
   • Permissions Model
   • Google Play Billing

Native Android Development flashcards for Mobile App Development

18 of 60 cards from the Native Android Development deck — real questions with worked answers.

1. In Android development, what is Gradle's role and what are the two main build files in a typical project?

   Gradle is the build automation system that compiles code, manages dependencies, and packages the APK/AAB. The two main files are the project-level build.gradle (defines plugins/repositories for all modules) and the module-level build.gradle (e.g., app/, defining SDK versions, dependencies, and build configuration).

2. What is the difference between compileSdk, minSdk, and targetSdk in an Android module's build configuration?

   compileSdk is the API level used to compile the app (which APIs are available). minSdk is the lowest Android version the app can run on. targetSdk declares the API level the app was tested against, controlling runtime behavior/compatibility flags.

3. What is the purpose of the AndroidManifest.xml file?

   It declares the app's essential information to the Android system: package identity, components (activities, services, broadcast receivers, content providers), required permissions, hardware/software features, and the app's entry point (launcher activity).

4. In the manifest, how do you designate an Activity as the app's launcher (entry point)?

   By adding an intent-filter inside the activity with the action android.intent.action.MAIN and the category android.intent.category.LAUNCHER.

5. Describe the standard Gradle-based Android project directory structure for source, resources, and manifest.

   Source code lives in src/main/java (or kotlin), resources in src/main/res, and the manifest at src/main/AndroidManifest.xml. Test code lives in src/test (unit tests, JVM) and src/androidTest (instrumented tests, on device).

6. What is an APK versus an AAB (Android App Bundle)?

   An APK is the installable package delivered directly to a device. An AAB is the publishing format uploaded to Google Play; Play then generates optimized, device-specific APKs (split by density, ABI, language) from it, reducing download size.

7. What is the difference between an Android emulator (AVD) and a physical device for testing?

   An emulator (Android Virtual Device) runs a virtualized Android system on the developer's machine, letting you test many API levels/screen sizes without hardware. A physical device gives real performance, sensors, and hardware behavior. Physical devices require USB debugging enabled via Developer Options.

8. How do you enable USB debugging on a physical Android device?

   Enable Developer Options by tapping Build Number seven times in Settings > About phone, then enable USB Debugging within Developer Options. The device then becomes accessible to adb/Android Studio over USB.

9. What is adb and name three commonly used adb commands.

   adb (Android Debug Bridge) is a command-line tool for communicating with devices/emulators. Common commands: adb devices (list connected devices), adb install <apk> (install an app), adb logcat (view device logs).

10. In Android resources, what is the purpose of configuration qualifiers, and give three examples.

    Configuration qualifiers let you provide alternative resources for different device configurations, selected automatically at runtime. Examples: -en (language English), -land (landscape orientation), -xxhdpi (extra-extra-high density screens), -sw600dp (smallest width 600dp for tablets).

11. How does Android choose which resource to use when multiple qualified directories exist (e.g., values, values-fr, values-fr-land)?

    Android eliminates directories that contradict the current device configuration, then picks the surviving directory that matches the highest-precedence qualifier. Qualifier precedence follows a fixed order (e.g., MCC, language, screen size, orientation, density); the best match wins, falling back to defaults.

12. What is the density-independent pixel (dp) and how does it relate to physical pixels?

    A dp is a virtual unit that scales with screen density so UI elements have consistent physical size. The relationship is $px = dp \times \frac{dpi}{160}$, where 160 dpi (mdpi) is the baseline at which $1\,dp = 1\,px$.

13. In Jetpack Compose, what is a Composable function and how is it marked?

    A Composable is a function that describes a piece of UI declaratively. It is marked with the @Composable annotation and can only be called from within other Composable functions. It emits UI rather than returning it.

14. In Jetpack Compose, what are Modifiers and how are they typically applied?

    Modifiers are objects that decorate or configure a Composable, altering size, layout, padding, background, click behavior, etc. They are passed via a modifier parameter and chained, e.g., Modifier.padding(8.dp).background(Color.Red).clickable { }. Order matters because each modifier wraps the previous.

15. In Compose, why does modifier order matter? Give an example.

    Modifiers are applied outside-in in chain order, so each affects what follows. For example Modifier.padding(16.dp).background(Color.Red) puts padding outside the red background (padding is uncolored), whereas Modifier.background(Color.Red).padding(16.dp) colors the whole area including the padded region.

16. What is recomposition in Jetpack Compose?

    Recomposition is the process where Compose re-executes Composable functions whose inputs (state) have changed, updating only the affected parts of the UI. It can happen frequently, may run in any order, and can be skipped for unchanged parts, so Composables must be side-effect free.

17. In Compose, what is the difference between remember and rememberSaveable?

    remember stores a value across recompositions but loses it on configuration changes (e.g., rotation) or process death. rememberSaveable additionally survives configuration changes and process recreation by saving to a Bundle, suitable for simple UI state.

18. What does mutableStateOf do, and why must it be wrapped in remember?

    mutableStateOf creates an observable State holder; reads are tracked so writes trigger recomposition. It must be wrapped in remember (val x by remember { mutableStateOf(0) }) so the state survives recomposition rather than being reset each time the Composable runs.

See more Native Android Development flashcards →

Planning Native Android Development for Mobile App Development

Native Android Development (Mobile App Development) FAQ