Prime 25 Android Interview Questions and Solutions For Skilled


The necessity for brand new applied sciences and their builders is rising because the world is dynamically reworking digitally. Everybody these days depends on apps for a wide range of capabilities, together with buying data and protecting in contact with each other in addition to day by day actions like buying, commuting, and invoice fee. However have you ever puzzled how a lot Android Builders are getting paid to do all this stuff? PayScale estimates that the annual compensation for an Android Software program Engineer in India is ₹3,99,594. Right here’s why it is advisable be thorough with the Prime 25 Superior Android Interview Questions to ace interviews in each product and service-based firms. 

Android Interview Questions and Answers for Experienced Android Developers

Likewise, the typical earnings for an skilled Android developer in India is ₹13,16,973/-.  Relating to Android Developer Salaries in the USA and the UK, the figures are $113,900 and £35,554, respectively. 

Many Android Builders are being employed by massive giants like Google, Amazon, Fb, and others in addition to rising startups like Zomato, Paytm, and CRED. In case you want to be employed by considered one of these firms, undergo these prime 25 Superior Android Interview Questions and their Solutions to ace in interviews:

Q1. What are the Lifecycle Occasions of an Android Exercise?

Lifecycle is an Android Structure Part launched by Google to help all Android builders. The Lifecycle is a category/interface that maintains details about an exercise/fragment’s present state and permits different objects to see this state by protecting observe of it. The occasions of an Android element’s lifecycle, reminiscent of these of an exercise or fragment, are the main target of the lifecycle element.

There are three main lessons to take care of it:

  1. Lifecycle
  2. Lifecycle Proprietor
  3. Lifecycle Observer

A. Lifecycle

A lifecycle is a technique that gives data on the Occasions that occurred in relation to an exercise or fragment. We now have a lifecycle class that makes use of the enumerations State and Occasion to trace the assorted parts. The lifecycle is set by Occasions and States. Each occasion has a novel state.



 OnCreate()Known as when the exercise is first created.
 OnStart()Known as when the exercise turns into seen to the consumer.
 OnResume()   Known as when the exercise begins interacting with the consumer.
 OnPause()Known as when the present exercise is being paused and the earlier exercise is resumed.
 OnStop()Known as when the exercise is now not seen to the consumer.
 OnDestroy()Known as earlier than the exercise is destroyed by the system(both manually or by the system to preserve reminiscence
 OnRestart()Known as when the exercise has been stopped and is restarting once more.

B. Lifecycle Proprietor

There’s a Lifecycle for each Exercise. This Exercise would be the lifecycle proprietor. LifecycleOwner is the one who will likely be constructed first when an exercise is initialized. Android LifeCycle is indicated by any class that implements the LifeCycleOwner interface. Fragments and Actions, as an example, implement the LifeCycleOwner interface as of Help Library model 26.1.0. By utilizing a LifeCycleRegistry and the interface as outlined above, one can develop distinctive LifeCycleOwner parts.

C. Lifecycle Observer

The Lifecycle Observer observes the exercise, data the lifecycle, and takes motion. This lifecycle Observer’s exercise relies on the lifetime of the lifecycle Proprietor. Each lifecycle proprietor has a lifecycle, and the lifecycle observer acts in response to an occasion or state within the proprietor’s lifecycle.

Get to know extra with an Instance: Exercise Lifecycle in Android with Demo App

Lifecycle of an Android App


Q2. How can Two Distinct Android Apps Work together?

On Android, there are primarily two methods for apps to speak with each other:

  • Intents, which permit information to be handed from one program to a different, and
  • Companies, which permit one app to supply performance to different apps.

Q3. How would you talk between Two Fragments?

All communication between fragments happens both via a shared ViewModel or via the associated Exercise. Direct communication between two Fragments shouldn’t be allowed.

To speak throughout fragments, it’s suggested to make a shared ViewModel occasion. Each fragments have entry to the ViewModel through the Exercise that accommodates them. If the information is uncovered utilizing LiveData, the opposite fragment will likely be pushed with the up to date information so long as it’s monitoring the LiveData from the ViewModel. The fragments can replace information inside the ViewModel.

Get to know extra with an Instance: Methods to Talk Between Fragments in Android?

This autumn. What’s Android Knowledge Binding?

A assist library referred to as the Knowledge Binding Library permits you to reap the benefits of binding UI parts to information sources in a structure utilizing a declarative format.

Layouts are continuously outlined in actions utilizing code that invokes UI framework APIs. As an illustration, within the code beneath, the userName subject of the viewModel variable is certain to a TextView widget by calling findViewById() to find the widget:

TextView textView = findViewById(;

The next part illustrates tips on how to assign textual content to the widget straight within the structure file utilizing the Knowledge Binding Library. By doing this, not one of the Java/Kotlin code from the earlier instance is important.

<TextView android:textual content="@{viewmodel.userName}" />

The professionals of utilizing Android Knowledge Binding:

  • Decreases the quantity of boilerplate code, which leads to
    • Much less coupling
    • Improved readability
    • A customized view with a powerful, simple-to-implement customized property
  • Quicker than findViewById
    • The binding extracts the Views with IDs in a single journey throughout the View Hierarchy.
    • When utilizing this technique with a number of Views, findViewById might take longer.

Get to know extra with an Instance: Knowledge Binding in Android with Instance

Q5. What’s a ViewHolder Sample? Why ought to We use it?

When the adapter calls the getView() perform, it additionally calls the findViewById() technique. Because of the cell CPU having to carry out such heavy lifting, the applying’s efficiency suffers and battery life degrades. FindViewById shouldn’t be used repeatedly. As a substitute, make the most of the ViewHolder design sample.

The effectivity of the applying improves as a result of a ViewHolder shops a reference to the id of the view useful resource, eliminating the necessity to “discover” it once more later.

Q6. What’s the distinction between Handler, AsyncTask, and Thread?

  • The Handler class presents a simple route for sending information to this thread and can be utilized to register to a thread. When utilizing one other background thread, a handler allows you to join with the UI thread.
  • The institution of a background course of and synchronization with the principle thread are each dealt with by the AsyncTask class. Moreover, it permits for reporting on the standing of ongoing duties.
  • A developer can make use of a Thread, which is the elemental constructing block of multithreading, with the next downside:
    • Deal with synchronization with the principle thread for those who publish again outcomes to the consumer interface
    • No default for canceling the thread
    • No default thread pooling
    • No default for dealing with configuration modifications in Android

Q7. Focus on Singletons vs Utility Context for the app-global state.

Static singletons might normally carry out the identical objective in a extra scalable method. In case your singleton requires a worldwide context (as an example, to register broadcast receivers), you possibly can present a Context to the tactic that retrieves it, which internally makes use of Context. When creating the singleton for the primary time, use getApplicationContext().

Nevertheless, singletons are tough to check and, if lazily initialized, introduce an indeterminism state with undetectable unwanted effects. One other subject that has been raised is visibility, and since singletons suggest world (= random) entry to shared states, delicate flaws might seem when concurrent applications are improperly synchronized.

Regardless of being a singleton in and of itself, the app context is maintained by the framework and has a clearly outlined life cycle, scope, and entry path. Due to this fact, in my view, that is the one place the place you need to keep an app-global state.

Q8. How can We use AsyncTask in several Actions?

One strategy is to construct a callback interface utilizing AsynTask in a number of Actions.

Create a Callback Interface

interface AsyncTaskListener<T> {
    public void onComplete(T outcome);

Then in your MainActivity 

public class MainActivity extends AppCompatActivity implements AsyncTaskListener<String> {
    public void onComplete(String outcome) {
        // your code right here

and TestActivity

public class TestActivity extends AppCompatActivity implements AsyncTaskListener<String> {
    public void onComplete(String outcome) {
        // your code right here

And Add to your AsyncTask class:

public class JSONTask extends AsyncTask<String, String, String>
    non-public AsyncTaskListener<String> listener;

public JSONTask(AsyncTaskListener < String > callback) {
    this.listener = callback;

protected void onPostExecute(String outcome) {
    // calling onComplate interface

Q9. What’s Android Jetpack Structure Elements?

You’ll be able to create dependable, examined, and maintainable apps with the help of the libraries that make up the Android Structure Elements. Android Jetpack consists of Android Structure Elements.

Following are the entire Android structure parts:

  • Knowledge Binding: It aids in declaratively connecting our app’s information sources and UI components.
  • Lifecycles: It controls the fragment and exercise lifecycles of our software, endures configuration modifications, prevents reminiscence leaks, and shortly hundreds information into our consumer interface.
  • LiveData: It alerts viewers to any database modifications. Construct information objects that alert views to database modifications through the use of LiveData. The whole lot required for in-app navigation in an Android software is taken care of.
  • Paging: It assists in regularly loading information from our information supply as wanted.
  • Room: It’s a library for SQLite object mapping. Use it to shortly convert SQLite desk information to Java objects whereas avoiding boilerplate code. The room presents SQLite assertion compile-time checks and may produce RxJava, Flowable, and LiveData observables. It maintains UI-related information in a lifecycle-aware method utilizing the ViewModel. It retains observe of UI-related data that isn’t misplaced when a program rotates.
  • WorkManager: It controls all background duties in Android beneath preset circumstances.

Learn Extra Right here: Jetpack Structure Elements in Android

Q10. What are some variations between Parcelable and Serializable?

We can not simply switch objects to actions in Android. The objects should both implement the Serializable or Parcelable interface to perform this.

A longtime Java interface is serializable. Merely implement the Serializable interface and supply the override strategies. This technique’s downside is that reflection is employed, and it takes time. Serializable is considerably slower than a Parcelable operation.

That is due, partly, to the truth that we explicitly state the serialization process reasonably than letting reflection infer it. Moreover, it is smart that the code has been extremely optimized with this finish in thoughts.


  • The serializable interface is slower than Parcelable.
  • In comparison with the Serializable interface, the Parcelable interface requires extra effort to implement.
  • You’ll be able to move a Parcelable array utilizing Intent.
  • Implementing a serializable interface is extra easy.
  • The serializable interface produces a number of short-term objects and considerably will increase the quantity of rubbish assortment.

Q11. What’s Broadcast Receiver?

Just like the publish-subscribe design sample, Android apps have the power to transmit and obtain broadcast messages from different Android apps and the Android system. The receiver element of an Android software is sometimes called the published receiver. This element permits us to register receivers for any application- or system-level occasion. When that occurs, the Android system will inform the registered receivers concerning the execution of the occasions in query.

Receivers can decide up considered one of two completely different sorts of broadcasts:

  1. Regular Broadcasts
  2. Ordered Broadcasts

Get to know extra with an Instance: Broadcast Receiver in Android With Instance

Q12. What’s MVVM in Android?

Mannequin—View—ViewModel (MVVM) is the industry-recognized software program Structure Sample that overcomes all drawbacks of MVP and MVC design patterns. MVVM suggests separating the information presentation logic(Views or UI) from the core enterprise logic a part of the applying. 

The separate code layers of MVVM are:

  • Mannequin: This layer is answerable for the abstraction of the information sources. Mannequin and ViewModel work collectively to get and save the information.
  • View: The aim of this layer is to tell the ViewModel concerning the consumer’s motion. This layer observes the ViewModel and doesn’t comprise any sort of software logic.
  • ViewModel: It exposes these information streams that are related to the View. Furthermore, it serves as a hyperlink between the Mannequin and the View.

The outline of Mannequin is as follows:

  • MODEL: (Reusable Code – DATA) Enterprise Objects that encapsulate information and habits of software area, Merely maintain the information. 
  • VIEW: (Platform Particular Code – USER INTERFACE) What the consumer sees, The Formatted information. 
  • VIEWMODEL: (Reusable Code – LOGIC) Hyperlink between Mannequin and View OR It Retrieves information from Mannequin and exposes it to the View. That is the mannequin particularly designed for the View.

Get to know extra with an Instance: Methods to Construct a Easy Word Android App utilizing MVVM and Room Database?

Q13. What’s the distinction between getContext(), getApplicationContext(), getBaseContext(), and this?

  • View.getContext(): Returns the context by which the view is executing in the intervening time. Usually, the lively Exercise.
  • Exercise.getApplicationContext(): Returns the context for your entire software (the method all of the Actions are operating inside). In case you require a context linked to the lifetime of your entire software, not simply the present Exercise, use this in place of the present Exercise context.
  • ContextWrapper.getBaseContext(): You employ a ContextWrapper for those who want entry to a Context from inside one other context. GetBaseContext can be utilized to retrieve the Context that ContextWrapper is referring to.

This at all times refers back to the present class object. getContext() just isn’t at all times the identical as this. As an illustration, within the Exercise class, you should utilize this since Exercise inherits from Context, however getContext() just isn’t a perform that’s included within the Exercise class.

Q14. What’s Android Jetpack?

Android Jetpack is a set of software program parts, libraries, instruments, and steering to assist in creating sturdy Android functions. Launched by Google in 2018, Jetpack includes current android assist libraries and android structure parts with an addition of the Android KTX library as a single modular entity. Jetpack consists of a large assortment of libraries which are inbuilt a approach to work collectively and make sturdy cell functions.

Its software program parts have been divided into 4 classes:

  1. Basis Elements
  2. Structure Elements
  3. Conduct Elements
  4. UI Elements

Key Advantages of Android Jetpack

  • Varieties a beneficial method for app structure via its parts
  • Remove boilerplate code
  • Simplify complicated process
  • Present backward compatibility as libraries like assist are unbundled from Android API and are re-packaged to androidx.*bundle
  • Inbuilt productiveness characteristic of the Kotlin Integration

Get to know extra:

Q15. What’s AndroidX?

The brand new open-source challenge often known as Android Extension Library, additionally referred to as AndroidX, is a substantial enchancment over the unique Android Help Library and can be utilized to create, take a look at, bundle, and ship libraries inside Jetpack. The AndroidX namespace consists of the Android Jetpack libraries. AndroidX is created independently of the Android OS and offers backward compatibility with earlier Android releases, very like the Help Library. The Help Library is totally changed by AndroidX packages, which offer characteristic parity and new libraries.

Moreover, AndroidX has the next functionalities as properly:

  • A single namespace with the letters AndroidX accommodates all AndroidX packages. The Help Library packages have been mapped to the equal androidx.* packages.
  • In contrast to the Help Library, AndroidX packages are individually up to date and maintained. The AndroidX packages rigorously comply with semantic versioning beginning with model 1.0.0. The AndroidX libraries for a challenge may be independently up to date.
  • All upcoming Help Library work will happen within the AndroidX library. This covers the upkeep of the unique Help Library objects in addition to the creation of latest Jetpack parts.

Q16. Clarify Dependency Injection.

When a lot of objects must be created which are depending on a lot of different objects in a challenge, it turns into tough because the challenge grows bigger. With this rising code base, good exterior assist is required to maintain observe of every thing. That is among the eventualities by which we make use of a Dependency Framework.

If we’ve got two actions, Exercise A and Exercise B. Each require an object Downloader, which in flip requires the request. The request will now be depending on Executor and HTTPClient. Dependency Injection relies on the idea of Inversion of Management, which states {that a} class’s dependencies ought to come from outdoors. In different phrases, no class ought to instantiate one other class. As a substitute, cases must be obtained from a configuration class.

Dependency Framework is used for the next causes:

  1. It facilitates the administration of complicated dependencies.
  2. It simplifies unit testing by permitting us to move all exterior dependencies in order that we are able to simply use mocked objects.
  3. It simply manages the thing’s scope (lifecycle).
  4. That is why we have to use a Dependency Injection Framework in Android, reminiscent of Dagger.

Q17. What’s Singleton Class in Android?

The Singleton Sample is a software program design sample that restricts the instantiation of a category to only “one” occasion. It’s utilized in Android Purposes when an merchandise must be created simply as soon as and used throughout the board. The primary cause for that is that repeatedly creating these objects, makes use of up system assets. The an identical object ought to due to this fact solely be created as soon as and used repeatedly. It’s utilized in conditions the place we solely require a single occasion of the category, reminiscent of with community providers, databases, and so on. We, due to this fact, create a singleton class to implement the Singleton sample in our challenge or product. On this article, we’ll take a look at tips on how to create singleton lessons in Java and Kotlin.

Get to know extra with an Instance: Singleton Class in Android

Q18. What’s Jetpack Compose in Android?

Jetpack Compose is a contemporary UI toolkit that’s designed to simplify UI growth in Android. It consists of a reactive programming mannequin with conciseness and ease of Kotlin programming language. It’s absolutely declarative as a way to describe your UI by calling some collection of capabilities that can remodel your information right into a UI hierarchy. When the information modifications or is up to date then the framework routinely remembers these capabilities and updates the view for you.

Get to know extra with an Instance: Fundamentals of Jetpack Compose in Android

Q19. What’s Coroutine on Android?

Coroutines are light-weight threads that enable us to do synchronous and asynchronous programming with ease. We are able to construct the principle security and change callbacks with coroutines with out blocking the principle thread. The concurrency design sample of the coroutine permits for code simplification and asynchronous execution, which may supply very excessive ranges of concurrency with a really small overhead.

Get to know extra with an Instance: Coroutines in Android

Q20. What’s Espresso in Android?

Google created the open-source Espresso testing framework for the Android consumer interface (UI). Espresso is a simple, environment friendly, and adaptable testing framework. Espresso checks keep away from the distraction of boilerplate content material, customized infrastructure, or sophisticated implementation particulars by stating expectations, interactions, and assertions in a simple and concise method. Espresso checks execute actually effectively! It permits you to forego your waits, syncs, sleeps, and polls whereas manipulating and making assertions on the applying UI whereas it’s idle.

Get to know extra with an Instance: UI Testing with Espresso in Android Studio

Q21. Varieties of Notifications in Android.

Notifications may very well be of varied codecs and designs relying upon the developer. In Basic, one will need to have witnessed these 4 sorts of notifications:

  1. Standing Bar Notification: Seems in the identical temporary structure as the present time and battery proportion.
  2. Notification Drawer Notification: Seems within the drop-down menu.
  3. Heads-Up Notification: Seems on the overlay display screen, eg: Chat App notification and OTP messages.
  4. Lock-Display Notification: Seems on the overlay of the locked display screen if enabled.

Get to know extra with an Instance: Notifications in Android with Instance

Q22. What’s Firebase Cloud Messaging?

Firebase Cloud Messaging or FCM, initially often known as Google Cloud Messaging or GCM, is a free cloud service offered by Google that permits app builders to ship notifications and messages to customers throughout many platforms, together with Android, iOS, and internet functions. It’s a free real-time technique for immediately sending notifications to shopper functions. Notifications with a payload of as much as 4Kb may be correctly transmitted through Firebase Cloud Messaging.

Q23. What’s the Google Android SDK?

The Google Android SDK is a set of instruments that builders use to create apps that run on Android-enabled gadgets. It features a graphical interface that simulates an Android-driven moveable surroundings, permitting them to check and debug their functions.

Q24. What’s the distinction between Volly and Retrofit?



Retrofit can parse many different sorts of responses routinely like:

  • Boolean: Internet API response, to be a boolean.
  • Integer: Internet API response, to be an integer.
  • Date: Internet API response, to be a Lengthy format date.
  • String: Internet API response, to be in String format.
  • Object: Internet API response, to be in a JSON object.
  • Collections: Internet API response, to be in a String Format.
  • StringRequest: Request converts the response right into a String.
  • JsonObjectRequest: Request and response routinely transformed right into a JSONObject.
  • JsonArrayRequest: Request and response routinely transformed right into a JSONArray.
  • ImageRequest: Request converts the response right into a decoded bitmap.
Retrofit doesn’t assist caching.Volley has a versatile caching mechanism. When a request is made via volley first the cache is checked for an acceptable response. Whether it is discovered there then it’s returned and parsed else a community hit is made.
Retrofit doesn’t assist any retrying mechanism. However it may be achieved manually by performing some additional code.In Volley, we are able to set a retry coverage utilizing the setRetryPolicy technique. It helps the personalized request timeout, variety of retries, and backoff multiplier.
Retrofit has full assist for Put up Requests and Multipart uploads.Volley helps each publish requests and multipart uploads however for publish requests, we’ve got to transform our java objects to JSONObject. Additionally for multipart uploads, we’ve got to do some additional code and use some extra lessons

Q25. Varieties of Databases in Android.

Relational, key-value, and object-oriented databases are the three fundamental sorts of databases utilized by Android gadgets.

  1. SQLite: A well-known relational cell database that’s accessible on each Android and iOS.
  2. ORMLite: A light-weight Object Relational Mapper or ORM designed for Java/Kotlin functions, together with Android.
  3. Room: An abstraction layer that sits on prime of SQLite. Makes use of database lessons as the first entry level for the continued information and the means by which the database is maintained.
  4. Firebase Cloud Firestore or Realtime Database: Complete multifunctional platform with a broad number of items, reminiscent of Cloud Firestore and Realtime Database.
  5. Realm: A fast, expandable substitute for SQLite that makes trendy cell functions’ information storing, querying, and synchronizing processes easy.


Please enter your comment!
Please enter your name here