Mobile App Development Native Android Development Syllabus

In Navigation Compose, how do you pass arguments between destinations via the route?

Define the route with a placeholder like "profile/{userId}" and declare arguments in the composable's arguments list with navArgument. Navigate with the concrete value (e.g., navigate("profile/42")) and read it from backStackEntry.arguments in the destination.

What is Material 3 (Material You) and how does it differ from Material 2 in Compose theming?

Material 3 is the latest Material Design system supporting dynamic color and an updated color/typography system. Compared to Material 2, it uses a larger set of color roles (primary, onPrimary, primaryContainer, surface, etc.), new components, and supports Android 12+ dynamic color derived from the user's wallpaper.

What are the three main pillars of a Compose MaterialTheme?

colorScheme (the app's color roles), typography (text styles like displayLarge, bodyMedium), and shapes (corner styles for components). Composables read these via MaterialTheme.colorScheme, MaterialTheme.typography, and MaterialTheme.shapes.

What is View Binding and what problem does it solve compared to findViewById?

View Binding generates a binding class per XML layout with direct, typed references to all views with IDs. It eliminates findViewById boilerplate, provides null safety and type safety, and prevents crashes from invalid IDs or type mismatches since references are checked at compile time.

How is View Binding enabled and used to inflate a layout in an Activity?

Enable it in the module build.gradle with buildFeatures { viewBinding true }. In the Activity, call val binding = ActivityMainBinding.inflate(layoutInflater), then setContentView(binding.root), and access views via binding.viewId.

What is the difference between View Binding and Data Binding?

View Binding only generates typed references to views (lightweight, no expressions in XML). Data Binding is a broader superset that also allows binding expressions directly in XML layouts (via <layout> tags), two-way binding, and observable data, at the cost of more build overhead.

What is a RecyclerView and why is it preferred over ListView?

RecyclerView is a flexible, efficient view for displaying large, scrollable data sets. It recycles (reuses) off-screen item views via the ViewHolder pattern, uses pluggable LayoutManagers, and supports animations and DiffUtil—giving better performance and flexibility than the older ListView.

What is the ViewHolder pattern in a RecyclerView Adapter?

A ViewHolder caches references to the item layout's views so they need not be looked up repeatedly during scrolling. The Adapter creates ViewHolders in onCreateViewHolder and binds data to their cached views in onBindViewHolder, enabling smooth recycling.

Name the three RecyclerView.Adapter methods you must override and what each does.

onCreateViewHolder (inflates an item layout and returns a ViewHolder), onBindViewHolder (binds data at a given position to the ViewHolder's views), and getItemCount (returns the total number of items in the data set).

What is DiffUtil and how does it improve RecyclerView performance?

DiffUtil calculates the minimal set of changes between two lists (using a difference algorithm) and dispatches fine-grained update notifications (insert/remove/move/change) instead of notifyDataSetChanged(). This enables efficient updates and automatic item animations. ListAdapter wraps DiffUtil for convenience.

What LayoutManager would you use for a grid in RecyclerView, and how does it differ from a vertical list?

Use GridLayoutManager (with a span count) for a grid; use LinearLayoutManager for a simple vertical or horizontal list. StaggeredGridLayoutManager creates a grid with items of varying sizes/offsets.

What is ConstraintLayout and what is its main advantage?

ConstraintLayout is a flexible layout that positions views using constraints (relationships) to sibling views and the parent. Its main advantage is building complex, flat (non-nested) view hierarchies, which improves layout performance and adapts responsively to different screen sizes.

In ConstraintLayout, what is a bias and what value centers a view?

Bias sets a view's position along a constrained axis as a fraction between its two opposing constraints. It ranges from 0.0 to 1.0; a horizontal_bias or vertical_bias of $0.5$ centers the view between its constraints.

In ConstraintLayout, what are Guidelines, Barriers, and Chains used for?

Guidelines are invisible reference lines (by dp or percent) to align views. Barriers move based on the extent of a set of referenced views. Chains link views bidirectionally so they share space via a chain style (spread, spread_inside, packed) or weights.

What is a ViewModel in Android Architecture Components and why does it exist?

A ViewModel holds and manages UI-related data in a lifecycle-conscious way, surviving configuration changes like rotation. It separates UI logic/state from the UI controller (Activity/Fragment), preventing data loss and avoiding heavy work in the view layer.

How does a ViewModel survive a configuration change but not stay forever?

A ViewModel is scoped to a lifecycle owner and retained across configuration changes (the Activity is recreated but the ViewModel instance persists). It is cleared—its onCleared() is called—only when the owner is permanently destroyed (e.g., Activity finished, not just rotated).

What is LiveData and what is its key characteristic?

LiveData is an observable, lifecycle-aware data holder. Its key characteristic is that it only delivers updates to observers in an active lifecycle state (STARTED or RESUMED) and automatically removes observers when their lifecycle is destroyed, preventing memory leaks and crashes from updating stopped UI.

What is the difference between LiveData and MutableLiveData?

MutableLiveData exposes setValue()/postValue() to change the data and is typically kept private inside a ViewModel. LiveData is the read-only supertype exposed publicly to observers, enforcing that only the owner can modify the value (encapsulation).

What is the difference between setValue() and postValue() on MutableLiveData?

setValue() updates the value synchronously and must be called from the main thread. postValue() schedules the update to be posted to the main thread and can be called from a background thread.

What is a lifecycle-aware component and what interface enables it?

A lifecycle-aware component adjusts its behavior based on the lifecycle state of an Activity or Fragment. It implements LifecycleObserver (or DefaultLifecycleObserver) and observes a Lifecycle owner, so it can start/stop work automatically at the right lifecycle events, reducing leaks and boilerplate.

List the main Android Activity lifecycle callbacks in the order they occur when an Activity starts and becomes visible.

onCreate() -> onStart() -> onResume(). When leaving the foreground the reverse-ish order is onPause() -> onStop() -> onDestroy(). onRestart() runs before onStart() when returning from a stopped state.

What is WorkManager and when should you use it?

WorkManager is the recommended Jetpack API for persistent, deferrable background work that must run reliably even if the app exits or the device restarts—e.g., syncing data, uploading logs, periodic backups. It respects system constraints (battery, network) and is guaranteed to execute.

What is the difference between OneTimeWorkRequest and PeriodicWorkRequest, and what is the minimum period for periodic work?

OneTimeWorkRequest runs a task once. PeriodicWorkRequest repeats work on an interval. The minimum repeat interval for periodic work is 15 minutes ($15\,\text{min}$).

How do you add Constraints to WorkManager work, and give two examples of constraints?

Build a Constraints object and set it on the WorkRequest via setConstraints(). Examples: setRequiredNetworkType(NetworkType.CONNECTED) (only run with network) and setRequiresCharging(true) (only run while charging).

What is the Jetpack Navigation Component (View-based) and what are its three main parts?

The Navigation Component is a framework for in-app navigation between destinations. Its three main parts are the navigation graph (an XML resource defining destinations and actions), the NavHost (a container displaying destinations, e.g., NavHostFragment), and the NavController (the object that manages navigation within the NavHost).

What is Safe Args in the Navigation Component?

Safe Args is a Gradle plugin that generates type-safe classes and builders for navigating and passing arguments between destinations. It replaces error-prone Bundle key/value passing with compile-time-checked Directions and Args classes.

In Kotlin coroutines, what is the difference between launch and async?

launch starts a coroutine that does not return a result and returns a Job (fire-and-forget). async starts a coroutine that computes a result and returns a Deferred<T>, whose value is retrieved by calling .await().

What is a suspend function in Kotlin and what is special about it?

A suspend function is a function that can pause (suspend) its execution without blocking the underlying thread, and resume later. It can only be called from another suspend function or a coroutine, and is the building block for asynchronous, non-blocking code.

In Kotlin coroutines, what are Dispatchers.Main, Dispatchers.IO, and Dispatchers.Default used for?

Dispatchers.Main runs on the UI thread (for UI updates). Dispatchers.IO is optimized for blocking I/O like network/disk operations. Dispatchers.Default is for CPU-intensive work such as sorting or parsing large data.

What is structured concurrency in Kotlin coroutines and what is a CoroutineScope?

Structured concurrency means coroutines are launched within a scope that tracks them, so they have a defined lifetime and are automatically cancelled together (e.g., when the scope is cancelled). A CoroutineScope defines this scope; examples include viewModelScope and lifecycleScope which cancel with their owner.

In Kotlin, what is a Flow and how does it differ from a suspend function returning a single value?

A Flow is a cold asynchronous stream that can emit multiple values sequentially over time, whereas a suspend function returns a single value. Flow is cold—the producer code runs only when a terminal operator like collect() is called.

What is the difference between StateFlow and SharedFlow?

StateFlow is a hot, state-holder flow that always has a current value and emits the latest value to new collectors (like an observable value; conflated). SharedFlow is a more general hot flow for events, without a required initial value, with configurable replay and buffering—suited to one-time events.

What is Retrofit and what does it do?

Retrofit is a type-safe HTTP client for Android/Java that turns a REST API into a Kotlin/Java interface. You declare endpoints with annotations (@GET, @POST, etc.), and Retrofit generates the implementation that performs the HTTP calls and converts responses using a converter.

In Retrofit, what do the annotations @Path, @Query, and @Body do?

@Path replaces a placeholder segment in the URL (e.g., users/{id}). @Query appends a URL query parameter (e.g., ?page=2). @Body sends an object as the HTTP request body, serialized by the configured converter (e.g., for POST/PUT).

What is OkHttp and how does it relate to Retrofit?

OkHttp is the underlying HTTP client library that actually executes network requests, managing connection pooling, caching, and interceptors. Retrofit is built on top of OkHttp; Retrofit handles the API-interface abstraction while OkHttp handles the low-level networking.

What is an OkHttp Interceptor and give a common use case?

An Interceptor is a component that can observe, modify, retry, or short-circuit HTTP requests and responses in a chain. A common use case is adding an authorization header to every request, or a logging interceptor (HttpLoggingInterceptor) to log request/response bodies for debugging.

What is JSON serialization/deserialization and why is a converter needed in Retrofit?

Serialization converts objects to JSON; deserialization parses JSON into objects. Retrofit itself only handles HTTP, so a converter factory (e.g., Moshi or Gson) is added to translate between the JSON payload and your data/model classes automatically.

Compare Moshi and Gson as JSON libraries for Android.

Both map JSON to objects. Moshi is modern, Kotlin-friendly (handles non-null and default values well), faster, and supports codegen with an annotation processor (avoiding reflection). Gson is older, reflection-based, and less aware of Kotlin nullability, which can allow null into non-null fields.

In Moshi/Gson, how do you map a JSON field whose name differs from your Kotlin property name?

Use a field-naming annotation: @Json(name = "json_field") in Moshi, or @SerializedName("json_field") in Gson, placed on the property so the library maps the differing JSON key to your property.

In Retrofit with coroutines, how do you declare a suspend API function and handle the response?

Declare the interface function as suspend with a return type of the deserialized model or Response<T>, e.g., suspend fun getUser(@Path("id") id: Int): User. Retrofit runs the call off the main thread; you call it from a coroutine (e.g., viewModelScope) and wrap it in try/catch to handle IO/HTTP exceptions.