Here are 100 Android developer interview questions and answers, covering core concepts, components, UI/UX, data storage, networking, concurrency, architecture patterns, testing, performance, and Kotlin/Java specifics. Each question is in bold, followed by a detailed answer. No dividing lines.
What is Android and what is its architecture?
Answer: Android is a Linux‑based open‑source operating system designed for mobile devices. Its architecture has five layers: Linux Kernel (hardware abstraction, drivers), Hardware Abstraction Layer (HAL), Android Runtime (ART) + native libraries, Application Framework (Activity Manager, Content Providers, etc.), and Applications. The kernel handles core system services.
What is an Activity? Describe its lifecycle.
Answer: An Activity is a single, focused screen representing a user interface. Lifecycle callbacks: onCreate (initialization), onStart (visible), onResume (interacting), onPause (partially obscured), onStop (not visible), onRestart, onDestroy (activity finishing or system killing). onSaveInstanceState is used to save transient state before onStop.
What is the difference between onPause and onStop?
Answer: onPause is called when the activity loses focus but is still partially visible (e.g., dialog overlay). onStop is called when the activity is no longer visible (e.g., another activity covers it entirely). onPause should be used to stop heavyweight operations or commit unsaved changes; onStop can release resources.
What is an Intent? Explain implicit and explicit intents.
Answer: An Intent is a messaging object used to request an action from another app component. Explicit intent specifies the target component by name (e.g., starting a specific Activity). Implicit intent declares a general action (e.g., ACTION_VIEW) and allows the system to find a suitable component (e.g., browser). Used to start activities, services, broadcast receivers.
What is a Service and how does it differ from an IntentService?
Answer: A Service is a component for long‑running operations in the background without a UI. IntentService (deprecated) was a subclass that handled asynchronous requests on a worker thread and stopped itself. Modern replacements: JobIntentService, WorkManager, or foreground services with notifications.
What is a BroadcastReceiver? How do you register it?
Answer: BroadcastReceiver listens for system-wide broadcast messages (e.g., battery low, boot completed). Two registration methods: static (declared in AndroidManifest.xml) and dynamic (registerReceiver in code). Static receivers work even when app is not running; dynamic only while the registering component is alive.
What is a ContentProvider? When would you use it?
Answer: A ContentProvider manages access to structured data, exposing it to other apps via a URI interface. Used for sharing data across apps (e.g., contacts, media). Also used internally with SQLite databases to provide a standard API. It implements CRUD operations and can enforce permissions.
What is a Fragment? Why are they used?
Answer: Fragment is a reusable UI component that can be embedded inside an Activity. It has its own lifecycle and can be added/removed dynamically. Fragments enable modular UI, support tablet layouts (multi‑pane), and allow back stack management at the fragment level.
What is the Fragment lifecycle?
Answer: Fragment lifecycle callbacks: onAttach, onCreate, onCreateView, onActivityCreated (deprecated, use viewLifecycleOwner), onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach. Fragment views are destroyed in onDestroyView, but fragment instance may remain.
What is the difference between Activity and FragmentActivity?
Answer: FragmentActivity is a base class that provides support for using fragments (especially from the support library) in older Android versions. Activity (from android.app) does not include fragment support out‑of‑the‑box. In modern Android, AppCompatActivity (extends FragmentActivity) is commonly used.
What is the AndroidManifest.xml file used for?
Answer: It declares app components (activities, services, receivers, content providers), required permissions, hardware/software features, API level support, and application metadata. It is the entry point for the Android system to understand the app.
What permissions are needed to access internet in Android?
Answer: android.permission.INTERNET and optionally android.permission.ACCESS_NETWORK_STATE. They must be declared in AndroidManifest.xml. Since Android 6.0 (API 23), dangerous permissions require runtime requests.
What is the difference between match_parent and wrap_content?
Answer: match_parent (or fill_parent) makes a view take as much space as its parent allows. wrap_content makes the view size itself to fit its content. In ConstraintLayout, match_parent is replaced by 0dp with constraints.
What is RecyclerView? How does it differ from ListView?
Answer: RecyclerView is a more flexible and efficient widget for large data sets. It enforces the ViewHolder pattern, provides built‑in layout managers (Linear, Grid, Staggered), item animations, and more efficient recycling. ListView is older, less customizable, and less performant.
What is the ViewHolder pattern in RecyclerView?
Answer: ViewHolder caches references to child views within a list row to avoid repeated findViewById calls. RecyclerView requires implementing a ViewHolder subclass and overriding onCreateViewHolder and onBindViewHolder. It improves scrolling performance.
What is ConstraintLayout and why is it useful?
Answer: ConstraintLayout is a flexible layout manager that allows positioning views relative to parent, other views, or guidelines using constraints. It reduces nesting (flatten layout hierarchy) and performs better than nested LinearLayouts. It is the recommended layout for complex UIs.
What is the difference between LinearLayout and RelativeLayout?
Answer: LinearLayout arranges children in a single row or column (orientation). RelativeLayout positions children relative to parent or other siblings (e.g., alignParentTop, below). ConstraintLayout supersedes both for complex responsive designs.
What is dp (density‑independent pixel) vs px?
Answer: dp abstracts screen density, allowing UI elements to appear the same physical size on different screens. px is actual screen pixels; never use for dimensions. 1 dp = 1 px on a 160 dpi screen. Use sp for text size (scalable with user font settings).
How do you handle configuration changes (e.g., screen rotation)?
Answer: By default, activity is destroyed and recreated. You can retain objects using ViewModel or onSaveInstanceState. To handle orientation changes manually, add android:configChanges="orientation|screenSize" in manifest, but this is discouraged for most cases. ViewModel with LiveData or saved state modules is the modern approach.
What is a ViewModel and why is it used?
Answer: ViewModel is a lifecycle‑aware component designed to store and manage UI‑related data across configuration changes. It survives activity/fragment recreation and does not hold direct references to views. It is part of Android Jetpack Architecture Components.
What is LiveData and how does it work?
Answer: LiveData is an observable data holder that respects lifecycle of app components (activities, fragments). It automatically updates observers that are in an active (STARTED or RESUMED) state and removes observers when destroyed. It helps avoid memory leaks and crashes due to stopped activities.
What is the difference between MutableLiveData and LiveData?
Answer: LiveData is immutable (read‑only) and does not expose setValue or postValue. MutableLiveData extends LiveData and adds those setter methods. Typically, expose LiveData to the UI and use MutableLiveData internally in ViewModel.
What is Room Database? How does it differ from SQLite?
Answer: Room is an ORM layer on top of SQLite that provides compile‑time checks, SQL query validation, and easier database access. It reduces boilerplate and integrates with LiveData and RxJava. Features: entities, DAOs (Data Access Objects), and database class. SQLite requires manual helper classes and raw SQL string management.
What is the difference between Entity, DAO, and Database in Room?
Answer: Entity represents a table (using @Entity). DAO (Data Access Object) defines methods to access the database (insert, update, query) annotated with SQL. Database is an abstract class extending RoomDatabase that ties entities and DAOs together.
What is the @Query annotation in Room?
Answer: @Query allows writing custom SQL queries in DAO methods. Room verifies the query syntax at compile time and returns the appropriate RxJava, LiveData, or Flow types.
How do you perform database migrations in Room?
Answer: Define a Migration class with addMigrations in Room database builder. It contains start version, end version, and a SQL statement to alter tables. If migrations are not provided, Room will recreate tables (destructive) if fallbackToDestructiveMigration is used.
What is SharedPreferences? What are its limitations?
Answer: SharedPreferences stores key‑value pairs of primitive data. Limitations: not suitable for large or structured data, not SQL queryable, synchronous writes can block UI, and it is not recommended for secure data. Modern alternatives: DataStore (Preferences or Proto) or Room.
What is Jetpack DataStore?
Answer: DataStore is a modern replacement for SharedPreferences. Two types: Preferences DataStore (key‑value) and Proto DataStore (typed with Protocol Buffers). It uses Kotlin coroutines and Flow, providing asynchronous, consistent, and transactional operations.
What is a WorkManager and when should you use it?
Answer: WorkManager is a background processing library for deferrable, guaranteed tasks that must run even if the app exits or device restarts. It respects OS power constraints (Doze mode). Use for tasks like uploading logs, syncing data, periodic maintenance. Not for immediate (use coroutines) or exact timed tasks (use AlarmManager).
What is the difference between Thread, AsyncTask (deprecated), and Coroutines?
Answer: Thread is low‑level, hard to manage. AsyncTask was a helper for short background tasks (deprecated). Coroutines are lightweight concurrency primitives from Kotlin, offering structured concurrency, cancellation, and easy thread switching. They are the recommended approach for background tasks in Android.
What is a CoroutineScope and how is it tied to the lifecycle?
Answer: CoroutineScope defines the lifecycle of coroutines. In Android, use viewModelScope (tied to ViewModel), lifecycleScope (tied to LifecycleOwner), and repeatOnLifecycle for UI updates. Proper scoping prevents memory leaks and cancels jobs when not needed.
What is a Flow in Kotlin? How does it relate to LiveData?
Answer: Flow is a cold asynchronous stream that emits values over time. LiveData is a hot observable tied to the Android lifecycle. LiveData can be converted to/from Flow using .asFlow() and .asLiveData(). Flow gives more operators and is lifecycle‑aware when used with repeatOnLifecycle.
What is the difference between launch and async in coroutines?
Answer: launch returns a Job and does not return a result; used for fire‑and‑forget tasks. async returns a Deferred<T> that can be awaited to get a result. Both are coroutine builders. Use async when you need a value.
What is a Sealed Class? How is it used in Android?
Answer: Sealed classes restrict class hierarchies to a limited set of subclasses. They are ideal for representing states (e.g., Result.Success, Result.Loading, Result.Error) in ViewModels. Combined with when expression, they guarantee exhaustive handling.
What is the difference between val and var in Kotlin?
Answer: val (value) is read‑only (immutable reference); can only be assigned once. var (variable) is mutable (reassignable). Use val whenever possible for immutability, which makes code safer and easier to reason about.
What is a lateinit keyword and its requirements?
Answer: lateinit allows non‑nullable var properties to be initialized after object construction. It avoids null checks. Requirements: can only be used with mutable var, must be non‑primitive type, must be initialized before access else exception. Common for Android views in activities/fragments.
What is a data class in Kotlin?
Answer: Data classes automatically derive equals(), hashCode(), toString(), copy(), and componentN() functions. They are perfect for model classes (e.g., User, Product). Requirements: primary constructor with at least one parameter, all parameters marked val or var. Cannot be abstract, open, sealed, or inner.
What is a companion object and how is it different from a Java static method?
Answer: A companion object is a singleton object tied to the class. Its members can be accessed using the class name (like static in Java). However, companion objects are actual objects and can extend classes, implement interfaces. In Java, static methods are not object instances.
What is the difference between object declaration and companion object?
Answer: object creates a singleton class (instance). companion object is an object inside a class, allowing class‑level members. Use object for utility classes, companion object for factory methods or constants tied to a class.
What is a Scope Function (let, run, with, apply, also)?
Answer: These functions execute a block of code on an object and provide a temporary scope. let (it, returns result), run (this, returns result), with (this, returns result; non‑extension), apply (this, returns object itself), also (it, returns object itself). Used for configuration, mapping, null safety.
What is the Android Application class?
Answer: It is a base class for maintaining global application state. You can extend it and override onCreate() for one‑time initialisation (e.g., dependency injection, logging). There is only one instance per app. Must be declared in AndroidManifest.
What is the difference between startActivity and startActivityForResult (deprecated)?
Answer: startActivity starts an activity without expecting a result. startActivityForResult (deprecated) expects a result back using onActivityResult. Modern approach: Activity Result API using registerForActivityResult.
What is the Activity Result API?
Answer: A type‑safe way to start activities and handle results, replacing deprecated startActivityForResult. Use registerForActivityResult with a contract (e.g., StartActivityForResult, RequestPermission). Results are delivered via callbacks and are lifecycle‑aware.
What is a PendingIntent?
Answer: A PendingIntent is a token that grants another application (or system) permission to perform an intent on behalf of your app. Used with notifications, alarms, and widgets. It preserves the identity of the original app.
What is onSaveInstanceState and when is it called?
Answer: It is called before an activity may be destroyed (e.g., rotation, system low memory) to save transient UI state. You save key‑value pairs in a Bundle, which is passed back in onCreate or onRestoreInstanceState. Not for persistent data (use ViewModel, database).
What is the difference between android:exported and android:permission?
Answer: android:exported indicates whether a component (activity, service, receiver) can be launched by other apps. android:permission requires the calling app to have a specific permission. Both declared in manifest.
What is an AppCompat library?
Answer: AppCompat provides backward‑compatible versions of Android UI components and themes (e.g., AppCompatActivity, Toolbar, AppCompatTextView). It allows using modern features on older Android versions.
What is Material Design and how does it apply to Android?
Answer: Material Design is Google’s design system for creating intuitive, beautiful user interfaces. Android implements it via Material Components library (MDC‑Android) providing widgets like MaterialButton, BottomNavigationView, and theming.
What is a ViewBinding and how does it differ from findViewById?
Answer: ViewBinding generates a binding class for each layout XML, allowing direct access to views with type‑safe references. It eliminates findViewById and null safety issues. It is simpler and faster than Kotlin synthetics (deprecated). DataBinding adds data binding expressions.
What is DataBinding and when is it used?
Answer: DataBinding allows declarative binding of UI components to data sources (e.g., ViewModel) using XML expressions (@{}). It reduces glue code and can update UI automatically when data changes. More complex than ViewBinding; use ViewBinding unless you need two‑way binding or observable UI.
What is the difference between ConstraintLayout and CoordinatorLayout?
Answer: ConstraintLayout is for positioning and sizing views relative to each other. CoordinatorLayout is a supercharged FrameLayout that provides coordination of child views (e.g., AppBarLayout, FloatingActionButton behavior). Often used with Material Design scrolling effects.
What is ViewModel SavedStateHandle?
Answer: SavedStateHandle allows a ViewModel to save and retrieve data across process death (not just configuration changes). It is injected into ViewModel constructor and used like a Bundle. Prevents data loss when system kills app.
What is the difference between LiveData and StateFlow?
Answer: Both are observable data holders. LiveData is lifecycle‑aware only on Android, while StateFlow (from Kotlin Flows) is platform‑independent. StateFlow requires a initial value and is part of coroutines. LiveData is simpler for basic use, but StateFlow is recommended for new projects with unified coroutine stack.
What is the purpose of AndroidManifest.xml uses‑permission tag?
Answer: It declares permissions that the app requires. The user is prompted at install time for normal permissions, or at runtime for dangerous permissions (API 23+).
What is an App Bundle (.aab) and how is it different from APK?
Answer: Android App Bundle is a publishing format that contains all app code and resources. Google Play generates optimized APKs for each device configuration (splits). APK is the final installable file. AAB reduces download size and is required for Play Store distribution.
What is ProGuard / R8?
Answer: R8 is the default code shrinker, obfuscator, and optimizer for Android. It removes unused code, renames classes/methods, and compresses resources. ProGuard is the older version. Use it to reduce APK size and protect against reverse engineering.
What is the difference between DVM (Dalvik Virtual Machine) and ART (Android Runtime)?
Answer: DVM used JIT (Just‑In‑Time) compilation; ART introduced AOT (Ahead‑Of‑Time) compilation (Android 5.0) and later hybrid (JIT + AOT + profile‑guided). ART improves performance, battery, and app startup time.
What are ADB commands? Give examples.
Answer: Android Debug Bridge (adb) is a command‑line tool. Examples: adb devices (list devices), adb logcat (view logs), adb install app.apk, adb shell, adb pull, adb push.
How do you debug memory leaks in Android?
Answer: Use Android Studio Profiler (Memory Profiler) to capture heap dumps, analyze allocations, and detect objects that should be garbage collected. LeakCanary is a popular library that automatically detects memory leaks in debug builds.
What is StrictMode and when is it used?
Answer: StrictMode detects accidental disk or network access on the main thread. It can log violations or crash during development to catch performance issues. Use in debug builds.
What are ANRs and how to avoid them?
Answer: Application Not Responding occurs when the UI thread is blocked for >5 seconds. Avoid by moving long operations (network, disk I/O, large computations) to background threads using coroutines, RxJava, or WorkManager. Use AsyncTask (deprecated) or HandlerThread.
What is the SQLiteDatabase class?
Answer: It provides methods to create, open, and manage SQLite databases. Use execSQL for raw SQL, insert, update, delete, and query methods. Room is a modern abstraction over SQLite.
What is a Cursor in Android?
Answer: A Cursor provides random read‑write access to the result set returned by a database query. It is used with ContentResolver or SQLite. Must be closed properly to avoid memory leaks.
What is the Loader class (deprecated)?
Answer: Loaders used to asynchronously load data (e.g., CursorLoader) and survive configuration changes. They are deprecated; use ViewModel + LiveData/Flow + Room instead.
What is Picasso / Glide?
Answer: These are image loading libraries that handle caching, resizing, and background loading. Glide is Google‑recommended; it offers GIF support, placeholder images, and efficient bitmap recycling.
What is Retrofit?
Answer: Retrofit is a type‑safe HTTP client for Android and Java. It converts HTTP API into Java interfaces using annotations (GET, POST). It supports OkHttp, coroutines, RxJava, and handles JSON parsing with converters (e.g., Moshi, Gson).
What is OkHttp?
Answer: OkHttp is an HTTP client that handles connection pooling, request/response caching, interceptors, and modern TLS. It is the base for Retrofit and other network libraries.
What is Moshi vs Gson?
Answer: Both convert JSON to Kotlin/Java objects. Moshi is newer, supports Kotlin reflection (KotlinJsonAdapter), null safety, and is used by Retrofit. Gson is older, widely used. Moshi is smaller and faster.
What are Android Architecture Components (Jetpack)?
Answer: A set of libraries that help design robust, testable, and maintainable apps. Core components: Lifecycle, LiveData, ViewModel, Room, Navigation, WorkManager, DataBinding, Paging. Encourages separation of concerns (MVVM).
What is Hilt?
Answer: Hilt is a dependency injection library built on Dagger, simplified for Android. It reduces boilerplate by generating injection components at compile time. Use @HiltAndroidApp, @Inject, @Module, @Provides, and predefined qualifiers.
What is Dagger? How is it different from Hilt?
Answer: Dagger is a fully static, compile‑time DI framework. Hilt is a wrapper on Dagger that provides standard Android components (Application, Activity, ViewModel) and reduces setup complexity. Use Hilt for new apps.
What is Mockito for testing?
Answer: Mockito is a mocking framework for unit tests. It creates mock objects, stubs method calls, and verifies interactions. Used to isolate the class under test from dependencies (retrofit, database).
What is Espresso?
Answer: Espresso is a UI testing framework for Android, providing synchronous view matching and action execution. It runs on the device and simulates user interactions. Ideal for integration tests.
What is Robolectric?
Answer: Robolectric allows unit tests to run on the JVM (without an emulator) by providing shadow implementations of Android SDK classes. It is faster than instrumented tests but may not cover all device behaviors.
What is a SurfaceView vs TextureView?
Answer: SurfaceView has a dedicated drawing surface that can be rendered by a separate thread (e.g., video playback). It does not support animations or transformations. TextureView uses hardware acceleration, supports transformations, but consumes more memory.
What is the difference between Canvas and OpenGL?
Answer: Canvas is a 2D drawing API built on Skia, simpler for UI drawing. OpenGL is a low‑level 3D graphics API, more powerful for games and complex rendering. OpenGL can be used with Canvas via hardware acceleration.
What is FragmentPagerAdapter vs FragmentStatePagerAdapter?
Answer: FragmentPagerAdapter stores fragments in memory permanently (for small number of pages). FragmentStatePagerAdapter destroys and recreates fragments as needed (for many pages). The latter also saves fragment state. Both are deprecated; use ViewPager2 with FragmentStateAdapter.
What is ViewPager2 and how does it differ from ViewPager?
Answer: ViewPager2 is built on RecyclerView, supports vertical orientation, RTL layout, and better diffing. It uses FragmentStateAdapter and does not require PagerTitleStrip adapters. ViewPager2 is the modern replacement.
What is ConstraintLayout Flow helper?
Answer: Flow is a virtual layout that arranges referenced views in a grid or horizontal/vertical chain, similar to Flexbox. It simplifies creating flexible responsive layouts without nesting.
What is MotionLayout?
Answer: MotionLayout is a subclass of ConstraintLayout for declarative animations (transition, swipe, keyframes). It can handle complex motion without custom code. Used for shared element transitions, swipe‑to‑dismiss, and interactive animations.
What is AppBarLayout and CollapsingToolbarLayout?
Answer: AppBarLayout is a vertical LinearLayout that can react to scrolling events of a sibling RecyclerView/NestedScrollView. CollapsingToolbarLayout wraps a Toolbar and allows it to collapse with parallax, pin mode, or exit until collapse.
What is CoordinatorLayout behavior?
Answer: Behaviors define how a child view interacts with other views. Example: FloatingActionButton behavior moves out of the way when Snackbar appears. You can write custom behaviors to coordinate animations.
What are Notifications and how do you create one?
Answer: Notifications are messages displayed outside the app’s UI. Create using NotificationManager, NotificationCompat.Builder, set content title/text, icon, priority, and specify an Intent wrapped in PendingIntent. Use channels (API 26+).
What is the difference between Activity and Dialog?
Answer: Activity has its own window and lifecycle, typically fills the screen. Dialog is a floating window that retains focus on the underlying activity. Use AlertDialog or custom Dialog for short‑interaction windows.
What is a Toast?
Answer: Toast is a transient message that appears on top of the UI for a short period. Use Toast.makeText(context, text, length).show(). For custom positioning, you can set gravity.
What is a Snackbar?
Answer: Snackbar is a lightweight, action‑enabled message that appears at the bottom of the screen. It can be swiped away. It is more versatile than Toast, recommended for user actions (undo). Use CoordinatorLayout to enable swipe.
What is RecyclerView ItemAnimator?
Answer: ItemAnimator controls animations when items are added, removed, moved, or changed (e.g., fade, slide). Default is DefaultItemAnimator. Override for custom effects.
What is DiffUtil in RecyclerView?
Answer: DiffUtil calculates the difference between old and new lists and dispatches minimal updates. It improves performance and simplifies adapter code. Use with ListAdapter (built‑in) or manually with RecyclerView and AsyncListDiffer.
What is rxJava? Why would you use it in Android?
Answer: RxJava is a reactive programming library for asynchronous, event‑based programs. It helps manage threading, error handling, and chaining operations. In Android, RxJava is used for network calls, database queries, and UI event streams. However, coroutines are now more common.
What is LiveData vs ObservableField?
Answer: LiveData is lifecycle‑aware (respects Activity/Fragment state) while ObservableField (DataBinding) is not. For UI updates, prefer LiveData or StateFlow.
What is a Parcelable and why is it used?
Answer: Parcelable is a serialization interface designed for Android to pass complex data between components (Activity, Service) and save state. It is more efficient than Java Serializable because it does not use reflection. Use @Parcelize Kotlin plugin.
What is @Parcelize?
Answer: Kotlin @Parcelize annotation generates Parcelable implementations automatically. Add kotlin‑parcelize plugin to build.gradle and annotate the data class. No need to write writeToParcel manually.
What is the difference between Activity and AppCompatActivity?
Answer: AppCompatActivity extends FragmentActivity and provides backward‑compatible features (ActionBar/Toolbar, Material Theme). It is part of AndroidX. Plain Activity does not include these.
What is the Android SoftInput mode?
Answer: android:windowSoftInputMode attribute controls how the soft keyboard interacts with the activity (adjustPan, adjustResize, adjustNothing, stateVisible, etc.). It is set in the manifest.
What is android:supportsRtl?
Answer: Enables right‑to‑left layout mirroring for languages like Arabic, Hebrew. When true, system mirrors layouts and uses start/end margins instead of left/right.
What is VectorDrawable?
Answer: VectorDrawable defines vector images using XML paths. It scales without quality loss, reduces APK size, and supports animation (AnimatedVectorDrawable). Use for simple icons.
What is WebView? When would you use it?
Answer: WebView renders web content inside your app. Use for displaying help pages, terms of service, or embedding web apps. Ensure proper handling of JavaScript interfaces and permissions to avoid security risks.
How do you secure sensitive data (API keys, passwords) in Android?
Answer: Do not hardcode keys. Use local.properties or BuildConfig only for non‑sensitive data. For secrets, use Android Keystore, EncryptedSharedPreferences, or rely on backend authentication. Do not store secrets in version control. Use secrets as environment variables in CI/CD.
What is SafetyNet (Play Integrity API)?
Answer: SafetyNet (now Play Integrity API) verifies device integrity (no root, emulator) and app authenticity. Used to prevent abuse and protect sensitive transactions.
What is Firebase and its common services?
Answer: Firebase is a mobile platform offering cloud services: Firestore (NoSQL DB), Authentication, Cloud Messaging (push notifications), Remote Config, Analytics, Crashlytics, and Storage. Helps accelerate development.
What is Cloud Messaging (FCM)?
Answer: Firebase Cloud Messaging (FCM) is a cross‑platform messaging solution to send push notifications and data messages. It works with a backend server and Google’s infrastructure.
What are the different launch modes in Android?
Answer: standard (new instance each time), singleTop (reuse if at top of stack), singleTask (single instance, clears activities above), singleInstance (isolated task). Defined in manifest or via intent flags.
What is a Task in Android?
Answer: A task is a stack of activities that users interact with. The home screen starts the main task. Each task has its own back stack. Launch modes affect task behavior.
How do you implement biometric authentication (fingerprint, face)?
Answer: Use BiometricPrompt API (Android 9+) with BiometricManager. It shows a system dialog and handles hardware, fallback, and error callbacks. You can also use androidx.biometric library for older versions.
Why should we hire you as an Android developer?
Answer: I have strong knowledge of Android SDK, Kotlin, Jetpack components (ViewModel, Room, Navigation), and modern architecture (MVVM). I write testable code, follow Material Design guidelines, and optimize for performance. I keep up with Google I/O announcements and migrate deprecated APIs. I am experienced with coroutines, Retrofit, and dependency injection (Hilt). I collaborate well with designers and backend teams, and I care about code quality, CI/CD, and user experience.
Conclusion
You’ve reached the final answer, and your heart is buzzing with that unmistakable passionate fire. The kind that made you fall for Android in the first place — the thrill of building an app that lives in people’s pockets, the obsession with smooth UI, the late nights taming RecyclerViews and Room databases. That passion never left you; it just got sharper, and now it’s ready to spill out in every interview answer with genuine, undeniable energy.
But you also kept it playful. Let’s be honest — wrangling fragments, hunting memory leaks, and dancing with coroutines can feel like a wild game, and you’ve learned to play it with a smile. That light-hearted curiosity is your secret weapon. It makes you approachable, creative, and fun to work with, and interviewers can sense that playful spark from across the table.
Now walk in radiant — glowing with preparation, confidence, and the kind of authentic excitement that lights up a room. You’re not just another candidate with a GitHub link. You’re an Android developer who builds with heart, learns with joy, and shines with readiness. Go dazzle them.