Mockpreps
🧑💼
🪴
Login now and master your exams with Mockpreps’ mock tests!
Top Interview Questions
Android is an open-source operating system designed primarily for mobile devices such as smartphones and tablets. It is developed and maintained by Google and based on the Linux kernel. Android powers billions of devices worldwide and is the most widely used mobile operating system globally.
Android provides a platform for developers to build applications using programming languages like Java and Kotlin, and it supports a vast ecosystem of apps available through app stores such as Google Play Store.
Android was originally developed by Android Inc., a company founded in 2003. In 2005, Google acquired Android Inc., and since then, it has continued to develop the operating system.
The first commercial Android device was released in 2008, marking the beginning of Android’s dominance in the mobile industry. Over time, Android has evolved through numerous versions, each introducing new features, performance improvements, and enhanced security.
Android is open source, meaning its source code is freely available under the Android Open Source Project (AOSP). This allows manufacturers and developers to modify and customize the OS according to their needs.
Android provides a highly intuitive and customizable user interface. Users can:
Change themes and wallpapers
Add widgets to the home screen
Customize layouts and settings
Android supports multitasking, allowing users to run multiple applications simultaneously. Features like split-screen mode enhance productivity.
Android runs on a wide range of devices, including:
Smartphones
Tablets
Smart TVs
Wearables
Automotive systems
The Android ecosystem includes millions of apps across categories such as:
Social media
Gaming
Productivity
Education
Entertainment
Most apps are distributed through the Google Play Store.
Android allows extensive customization compared to other operating systems. Users can:
Install custom launchers
Use widgets
Modify system settings
Android includes multiple security mechanisms such as:
App sandboxing
Regular security updates
Google Play Protect (malware scanning)
Android is built on a layered architecture consisting of several components:
The foundation of Android is the Linux kernel, which handles:
Hardware abstraction
Memory management
Process management
Device drivers
HAL provides standard interfaces that allow Android to communicate with hardware components like cameras, sensors, and audio devices.
ART is responsible for executing Android applications. It converts compiled bytecode into machine code for efficient execution.
Android includes a set of native C/C++ libraries that provide functionalities such as:
Graphics rendering
Database management
Media playback
This layer provides high-level services used by applications, such as:
Activity Manager
Window Manager
Content Providers
Resource Manager
This is the top layer where user applications reside, including:
System apps (Phone, Messages, Settings)
Third-party apps installed by users
Android apps are primarily developed using:
Java
Kotlin (modern preferred language)
Developers use integrated development environments (IDEs) such as Android Studio, which provides tools for coding, debugging, and testing applications.
An Android application typically consists of:
An activity represents a single screen with a user interface.
Services run in the background to perform long-running operations.
These components respond to system-wide broadcast messages.
Content providers manage shared data between applications.
Android versions are released regularly with improvements and new features. Each version is traditionally named after desserts (e.g., Cupcake, KitKat, Lollipop), although recent versions use numeric naming.
Examples of Android versions include:
Android 10
Android 11
Android 12
Android 13
Android 14
Each update typically introduces:
UI enhancements
Performance improvements
Security upgrades
Android’s open-source nature allows manufacturers to customize it without licensing fees.
Android dominates the global smartphone market, making it an attractive platform for developers.
With millions of apps available, users have access to a wide range of functionalities.
Users and manufacturers can customize Android extensively.
Android provides robust tools, documentation, and community support for developers.
There are many devices with different screen sizes, hardware configurations, and Android versions, which can complicate app development.
Because it is open source and widely used, Android can be more vulnerable to malware if users install apps from untrusted sources.
Performance can vary depending on the device manufacturer and hardware specifications.
Android is often compared with iOS:
| Feature | Android | iOS |
|---|---|---|
| Openness | Open source | Closed source |
| Customization | High | Limited |
| Devices | Many manufacturers | Apple devices only |
| App Store | Google Play Store | Apple App Store |
| Flexibility | High | Moderate |
Android is used by many major smartphone manufacturers, including:
Samsung
Xiaomi
OnePlus
Oppo
Vivo
These companies customize Android with their own user interfaces and features.
Android is used in various domains:
The primary use of Android is in smartphones for communication, entertainment, and productivity.
Android tablets are used for education, media consumption, and business tasks.
Android TV provides streaming and entertainment capabilities.
Android powers smartwatches and fitness trackers.
Android Auto is used in vehicles for navigation, media, and communication.
Android continues to evolve with advancements in:
Artificial intelligence integration
Foldable devices
Improved privacy and security features
Better performance optimization
With continuous innovation from Google, Android remains a dominant force in the mobile technology ecosystem.
Android is a powerful, flexible, and widely adopted operating system that has transformed the mobile industry. Its open-source nature, vast app ecosystem, and support for a wide range of devices make it a preferred choice for both users and developers.
From smartphones to smart TVs and wearable devices, Android plays a significant role in modern digital life. With ongoing improvements and global adoption, Android continues to shape the future of mobile computing.
Answer:
Android is an open-source mobile operating system developed by Google, mainly used for smartphones, tablets, and other devices.
👉 It is based on the Linux kernel and supports apps written in Java, Kotlin, and C++.
Answer:
Android apps are built using four main components:
Activity – UI screen
Service – Background tasks
Broadcast Receiver – System-wide events
Content Provider – Data sharing between apps
Answer:
An Activity represents a single screen with a user interface.
👉 Example:
Login screen
Home screen
Each activity has a lifecycle.
Answer:
The lifecycle defines the states an activity goes through:
onCreate() → initialization
onStart() → visible
onResume() → user interaction
onPause() → partially visible
onStop() → not visible
onDestroy() → destroyed
👉 Helps manage resources efficiently.
Answer:
A Fragment is a reusable portion of UI inside an activity.
👉 Used for:
Multi-pane layouts (tablet UI)
Reusability
Answer:
An Intent is used to navigate between activities or communicate between components.
Types:
Explicit Intent → target specific activity
Implicit Intent → system decides action
Example:
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent);
Answer:
| Explicit Intent | Implicit Intent |
|---|---|
| Targets a specific component | Uses system to find component |
| Used within app | Used for external actions |
Answer:
Declares which intents a component can respond to.
👉 Defined in AndroidManifest.xml
Answer:
Views are UI elements like:
TextView
Button
EditText
ImageView
Answer:
A container that holds and arranges views.
Examples:
LinearLayout
RelativeLayout
ConstraintLayout
Answer:
A flexible layout that allows positioning views relative to each other.
👉 Preferred for modern UI design.
Answer:
Used to display large lists efficiently by recycling views.
👉 Better than ListView.
Answer:
| ListView | RecyclerView |
|---|---|
| Older | Modern |
| Less flexible | Highly flexible |
| No ViewHolder required | Uses ViewHolder pattern |
Answer:
SharedPreferences → key-value storage
SQLite Database → structured data
Room Database → abstraction over SQLite
File storage
Answer:
Used to store small amounts of data like:
User settings
Login status
Answer:
A lightweight relational database built into Android.
Answer:
An abstraction layer over SQLite that simplifies database operations.
Answer:
To avoid blocking the UI thread.
👉 Long tasks:
Network calls
Database operations
Answer:
A class used to perform background operations (now deprecated).
Answer:
Kotlin Coroutines
Executor framework
WorkManager
Answer:
Using libraries like:
Retrofit
Volley
OkHttp
Answer:
A type-safe HTTP client used for API communication.
Answer:
Permissions allow apps to access system features like:
Camera
Location
Contacts
Answer:
Permissions requested at runtime (Android 6.0+).
Answer:
Used to receive system-wide events like:
Battery low
Network changes
Answer:
A component that runs in the background without UI.
Types:
Started Service
Bound Service
Answer:
Used for deferrable background tasks that need guaranteed execution.
Answer:
A configuration file that declares:
App components
Permissions
App metadata
Answer:
Concise code
Null safety
Coroutines support
Interoperability with Java
Answer:
Prevents null pointer exceptions using:
?
!!
Safe calls ?.
Answer:
Launcher activity is defined in manifest
System launches the app via intent
Answer:
Activity is destroyed and recreated by default.
👉 Data can be preserved using:
ViewModel
onSaveInstanceState()
Answer:
Changes like:
Screen rotation
Language change
Answer:
ViewModel
onSaveInstanceState
Persistent storage
👉 Explain:
App idea
Features
Tech used
Challenges faced
Your contribution
👉 Example points:
Wide user base
Interest in mobile apps
Problem-solving
UI design understanding
Logical thinking
Debugging skills
✔ Focus on:
Activity lifecycle
Intents
RecyclerView
Fragments
Basic networking
✔ Practice:
Build simple apps:
Login app
To-do app
API-based app
✔ Be ready to:
Explain your project in detail
Write simple Android code
Answer lifecycle-related questions
Modern Android apps follow layered architecture:
UI Layer
Activities / Fragments / Compose UI
ViewModel
Domain Layer (optional)
Business logic
Use cases
Data Layer
Repositories
Network (Retrofit)
Local DB (Room)
👉 Recommended pattern:
MVVM (Model-View-ViewModel)
Clean Architecture
MVVM separates UI from business logic.
Model → Data layer
View → UI (Activity/Fragment)
ViewModel → Manages UI state
View → ViewModel → Repository → Data source
👉 Benefits:
Testable
Lifecycle-aware
Decoupled components
| Feature | Activity | Fragment |
|---|---|---|
| Lifecycle | Independent | Dependent on Activity |
| Reusability | Low | High |
| UI | Full screen | Part of UI |
👉 Fragments are used for modular UI design.
onCreate()
onStart()
onResume()
onPause()
onStop()
onDestroy()
👉 Important:
Save state in onSaveInstanceState()
Restore in onCreate()
ViewModel:
Stores UI-related data
Survives configuration changes (e.g., rotation)
class MyViewModel : ViewModel() {
val data = MutableLiveData<String>()
}
👉 Benefits:
No memory leaks
Lifecycle-aware
Separates UI logic
Observable data holder that respects lifecycle.
val name = MutableLiveData<String>()
👉 Features:
Lifecycle-aware
Prevents memory leaks
Automatically updates UI
| Feature | LiveData | Flow | StateFlow |
|---|---|---|---|
| Lifecycle aware | Yes | No | No |
| Cold/Hot | Hot | Cold | Hot |
| Backpressure | No | Yes | Yes |
👉 Modern apps prefer StateFlow + Flow (Kotlin Coroutines)
Lightweight threads for asynchronous programming.
viewModelScope.launch {
val data = repository.getData()
}
👉 Benefits:
Non-blocking
Structured concurrency
Efficient threading
Controls thread execution:
| Dispatcher | Use |
|---|---|
| Main | UI |
| IO | Network/DB |
| Default | CPU intensive |
withContext(Dispatchers.IO) {
// network call
}
Type-safe HTTP client for Android.
interface ApiService {
@GET("users")
suspend fun getUsers(): List<User>
}
👉 Uses:
REST APIs
JSON parsing (Gson/Moshi)
SQLite abstraction layer.
@Entity
data class User(
@PrimaryKey val id: Int,
val name: String
)
👉 Benefits:
Compile-time verification
Type safety
Built-in DAO pattern
Data Access Object defines DB operations.
@Dao
interface UserDao {
@Query("SELECT * FROM user")
fun getUsers(): List<User>
}
Efficiently loads large datasets in chunks.
👉 Used in:
Infinite scrolling lists
Pagination APIs
Handles background tasks reliably.
👉 Features:
Survives app restarts
Works with constraints (network, battery)
Dependency injection library by Google.
@HiltAndroidApp
class MyApp : Application()
👉 Benefits:
Reduces boilerplate
Manages dependencies
Improves testability
Avoid memory leaks
Use lazy loading
Optimize layouts (ConstraintLayout)
Use RecyclerView efficiently
Avoid heavy work on main thread
Use caching
Occurs when main thread is blocked for too long.
👉 Causes:
Long network calls on main thread
Heavy computations
Deadlocks
👉 Fix:
Move work to background threads
Objects not garbage collected due to lingering references.
👉 Common causes:
Static references to Activity
Anonymous inner classes
Improper context usage
👉 Tools:
LeakCanary
Android Profiler
Use ViewHolder pattern
Avoid unnecessary binding
Use DiffUtil
Enable stable IDs
Efficiently updates RecyclerView by calculating differences.
DiffUtil.calculateDiff(...)
MVVM + Clean Architecture
Use repositories
Modularize app
Dependency injection (Hilt)
Use single source of truth
Use Flow/StateFlow
ViewModel survives rotation
Save UI state using SavedStateHandle
Avoid recreating data
Local DB (Room)
Cache API responses
Sync strategy
WorkManager for background sync
Use sealed classes for response states
sealed class Result {
object Success : Result()
object Error : Result()
object Loading : Result()
}
Use HTTPS
Encrypt sensitive data (EncryptedSharedPreferences)
Avoid hardcoding secrets
Use ProGuard/R8 obfuscation
Root detection (optional)
Heavy UI binding
Inefficient RecyclerView usage
Large images not optimized
Main thread blocking
Logcat analysis
Crashlytics
Stack trace inspection
Reproduce issue
ProGuard/R8
Remove unused resources
Use vector drawables
Split APKs / App bundles
Feature modules
Core modules
Dependency isolation
Gradle modularization
WebSockets
Firebase Realtime Database
Polling APIs
Push notifications
| Type | Behavior |
|---|---|
| Cold Flow | Starts on collection |
| Hot Flow | Emits continuously |
| Feature | StateFlow | SharedFlow |
|---|---|---|
| Holds state | Yes | No |
| Replay | 1 | Configurable |
| Use case | UI state | Events |
Coroutines are bound to lifecycle scopes.
👉 Prevents:
Leaked coroutines
Uncontrolled background tasks
Code shrinking
Obfuscation
Optimization
Modern UI toolkit for declarative UI.
👉 Benefits:
Less boilerplate
Reactive UI
State-driven rendering
Interviewers expect:
Strong architecture understanding
Threading & concurrency knowledge
Real-world debugging experience
Performance optimization skills
Clean code practices
