Android Development Interview Questions & Answers

Android is an open-source mobile operating system developed by Google. It is built on top of the Linux kernel and is primarily designed for touch-based devices such as smartphones and tablets.

Internally, Android follows a layered architecture:

• Linux Kernel - Handles memory management, device drivers, and process management.
• Hardware Abstraction Layer (HAL) - Connects hardware components with the software layer.
• Android Runtime (ART) - Executes Android apps using DEX bytecode.
• Native Libraries - Includes SQLite, WebKit, OpenGL, etc.
• Application Framework - Provides APIs like Activity Manager and Content Providers.
• Applications - User-facing apps built on top of the framework.

Understanding this layered structure helps when debugging system-level issues.

The Activity lifecycle describes how an activity transitions between states.

The main lifecycle methods include:

• onCreate() - Activity is initialized.
• onStart() - Activity becomes visible.
• onResume() - Activity comes to foreground.
• onPause() - Activity partially hidden.
• onStop() - Activity completely hidden.
• onDestroy() - Activity is destroyed.

In practical development, heavy tasks should not run inside lifecycle methods like onResume(), as it may slow UI rendering.

An Intent is a messaging object used to request an action from another component.

There are two types:

• Explicit Intent - Used to open a specific Activity.
• Implicit Intent - Used to perform general actions like opening a browser.

Intents are essential for communication between Activities and other app components.

A Fragment represents a reusable portion of the UI inside an Activity.

Fragments are useful for:

• Supporting multiple screen sizes
• Creating modular UI components
• Implementing tablet layouts

Fragments share lifecycle with the parent Activity but are lighter and more flexible.

RecyclerView is a flexible view for displaying large datasets efficiently.

It improves performance by recycling views instead of recreating them.

Key components:

• Adapter
• ViewHolder
• LayoutManager

RecyclerView supports animations and multiple view types, making it more powerful than ListView.

An Activity represents a single screen with a user interface. It is one of the core components of Android applications.

Each Activity follows a defined lifecycle managed by the system.

The four main Android components are:

• Activity
• Service
• Broadcast Receiver
• Content Provider

The Activity lifecycle includes:

• onCreate()
• onStart()
• onResume()
• onPause()
• onStop()
• onDestroy()

Understanding lifecycle helps manage resources efficiently.

Intent is a messaging object used to request an action from another component.

It can be explicit or implicit.

A Service is a component that runs in the background to perform long-running operations without user interaction.

BroadcastReceiver responds to system-wide broadcast announcements.

Example: battery low, network change.

A Fragment represents a reusable portion of UI within an Activity.

Fragments improve modular UI design.

RecyclerView is a flexible and efficient way to display scrollable lists.

It reuses views for better performance.

ANR (Application Not Responding) occurs when the app does not respond within 5 seconds on the main thread.

Heavy operations must not run on UI thread.

AsyncTask was used for background tasks.

It is now deprecated. Developers use Coroutines or WorkManager instead.

Parcelable is Android-specific and faster.

Serializable is standard Java but slower.

ViewModel stores UI-related data and survives configuration changes.

LiveData is lifecycle-aware observable data holder.

WorkManager schedules deferrable background tasks that must run even if app exits.

ProGuard/R8 shrinks, optimizes, and obfuscates code for production builds.

ANR stands for Application Not Responding. It occurs when the main thread is blocked for more than 5 seconds.

To prevent ANR:

• Avoid network calls on main thread
• Use background threads or coroutines
• Optimize long-running tasks

ANR can severely impact user experience, so performance optimization is critical.

ViewModel is part of Android Architecture Components. It stores UI-related data and survives configuration changes such as screen rotation.

Without ViewModel, data would be lost when Activity is recreated.

It helps maintain clean separation between UI and business logic.

MVVM stands for Model-View-ViewModel.

Model handles data.

View handles UI.

ViewModel handles logic and data preparation.

This separation improves testability and maintainability.

Dependency Injection is a design pattern where dependencies are provided externally rather than created inside the class.

Popular DI tools in Android:

• Dagger
• Hilt

It reduces tight coupling and improves code testability.

Application Context is tied to the lifecycle of the entire app, while Activity Context is tied to a specific Activity.

Use Application Context for long-lived operations like database access. Use Activity Context when UI-related resources are required.

Using Activity Context improperly may cause memory leaks.

commit() saves data synchronously and returns a boolean indicating success.

apply() saves data asynchronously and does not return a result.

apply() is generally preferred because it does not block the main thread.

Room is an abstraction layer over SQLite provided by Android Jetpack.

It simplifies database access by using:

• Entity
• DAO
• Database class

Room provides compile-time query verification, reducing runtime crashes.

A foreground service shows a persistent notification and continues running even when the app is not visible.

A background service runs silently and may be stopped by the system in newer Android versions.

Foreground services are used for music players, GPS tracking, etc.

StrictMode is a developer tool that detects accidental disk or network access on the main thread.

It helps identify performance issues early during development.

Explicit broadcasts are sent to a specific receiver.

Implicit broadcasts are system-wide and can be received by multiple apps.

Android restricts implicit broadcasts in newer versions for performance reasons.

AndroidManifest.xml declares:

• Activities
• Services
• Permissions
• App metadata

It is essential for app configuration and component registration.

Starting from Android 6.0, dangerous permissions must be requested at runtime.

Examples include:

• Camera
• Location
• Storage

This improves user privacy and security.

View Binding generates a binding class for each XML layout.

It eliminates the need for findViewById() and reduces null pointer exceptions.

Content Providers manage access to structured data.

They allow sharing data between applications securely.

Jetpack is a collection of Android libraries that help build robust apps.

It includes components like:

• Navigation
• Room
• LiveData
• ViewModel

Threads are system-level constructs and expensive to create.

Coroutines are lightweight and managed by Kotlin runtime.

Coroutines simplify asynchronous programming significantly.

Navigation Component simplifies in-app navigation.

It provides a single-activity architecture with a navigation graph.

ConstraintLayout allows flexible positioning of UI elements.

It reduces nested layouts and improves performance.

Android Keystore stores cryptographic keys securely.

Keys stored here cannot be extracted, improving app security.

Cold start occurs when app process is not running.

Warm start occurs when app process is already in memory.

Optimizing cold start improves first impression performance.

Serializable is a Java interface used for object serialization.

Parcelable is Android-specific and faster because it is optimized for IPC.

Parcelable is preferred in Android development for performance reasons.

Android uses garbage collection to free unused memory.

However, developers must avoid memory leaks by:

• Avoiding static references to Activities
• Unregistering listeners
• Using WeakReference where appropriate

Proper memory handling prevents app crashes and improves stability.

A Service is a component that runs in the background to perform long-running operations. It runs on the main thread by default, so heavy work must be moved to a separate thread.

IntentService (now deprecated in newer APIs) was a subclass of Service that handled asynchronous requests on a worker thread automatically and stopped itself after completing the task.

In modern Android development, IntentService is replaced with WorkManager or foreground services.

WorkManager is a Jetpack library used to schedule background tasks that need guaranteed execution, even if the app exits.

It is ideal for:

• Uploading logs
• Syncing data
• Deferred background tasks

WorkManager automatically chooses the best background scheduling API depending on the Android version.

LiveData is lifecycle-aware and commonly used in MVVM architecture.

Flow (from Kotlin Coroutines) is more powerful and supports advanced operators like map, filter, and combine.

Flow is generally preferred in modern Android apps because it integrates better with coroutines and supports cold streams.

Data Binding allows binding UI components directly to data sources in XML layouts.

This reduces boilerplate code and improves readability.

It works well with MVVM architecture and supports two-way data binding.

Jetpack Compose is Android’s modern UI toolkit that replaces XML layouts with declarative Kotlin code.

Instead of modifying views manually, you describe the UI state and Compose updates automatically.

It simplifies UI development and reduces boilerplate significantly.

Broadcast Receivers respond to system-wide broadcast messages like battery low, network changes, or boot completed.

They are lightweight components and should not perform heavy operations directly.

For long-running work, they should delegate tasks to WorkManager or Services.

Offline support is implemented using local storage solutions such as:

• Room Database
• SharedPreferences
• DataStore

A common pattern is caching API responses locally and syncing when network becomes available.

The Repository pattern acts as a single source of truth for data.

It abstracts whether data comes from:

• Network
• Database
• Cache

This keeps ViewModel clean and improves testability.

ProGuard is a tool that shrinks, optimizes, and obfuscates code in Android apps.

It reduces APK size and protects intellectual property by renaming classes and methods.

It is configured inside proguard-rules.pro file.

To secure sensitive data:

• Use EncryptedSharedPreferences
• Use Android Keystore
• Enable HTTPS with certificate pinning
• Avoid storing secrets in source code

Security is critical especially in fintech, healthcare, and enterprise apps.