Top 25 Android Interview Questions and Answers For Experienced

The need for new technologies and their developers is increasing as the world is dynamically transforming digitally. Everyone nowadays relies on apps for a variety of functions, including acquiring information and keeping in touch with one another as well as daily activities like shopping, commuting, and bill payment. But have you wondered how much Android Developers are getting paid to do all these things? PayScale estimates that the annual compensation for an Android Software Engineer in India is ₹3,99,594. Here's why you need to be thorough with the Top 25 Advanced Android Interview Questions to ace interviews in both product and service-based companies. 

Likewise, the average income for an experienced Android developer in India is ₹13,16,973/-.  When it comes to Android Developer Salaries in the United States and the United Kingdom, the figures are $113,900 and £35,554, respectively. 

Many Android Developers are being hired by big giants like Google, Amazon, Facebook, and others as well as growing startups like Zomato, Paytm, and CRED. If you wish to be employed by one of these companies, go through these top 25 Advanced Android Interview Questions and their Answers to ace interviews.

List of 25+ Android Interview Questions and Answers

1. What are the Lifecycle Events of an Android Activity?

Lifecycle is an Android Architecture Component that helps in maintaining information about an activity/fragment's current state and allows other objects to see this state by keeping track of it. The events of an Android component's lifecycle, such as those of an activity or fragment, are the focus of the lifecycle component.

Key Components of Android Lifecycle

1. Lifecycle
2. Lifecycle Owner
3. Lifecycle Observer

A. Lifecycle

The Lifecycle class provides information about the state and events occurring in an activity or fragment. It depends on two factors:

1. State – Represents the current lifecycle state of the component.
2. Event – Represents lifecycle events that trigger state transitions.

B. Lifecycle Owner

There is a Lifecycle for every Activity. This Activity will be the lifecycle owner. LifecycleOwner is the one who will be constructed first when an activity is initialized. Android LifeCycle is indicated by any class that implements the LifeCycleOwner interface. Fragments and Activities, for instance, implement the LifeCycleOwner interface as of Support Library version 26.1.0. By using a LifeCycleRegistry and the interface as defined above, one can develop unique LifeCycleOwner components.

C. Lifecycle Observer

The LifecycleObserver keeps track of an activity or fragment's lifecycle and performs actions based on its state. It listens for lifecycle events like onCreate(), onResume(), and onPause(), helping developers manage tasks at the right time. Using LifecycleObserver, components can start and stop themselves automatically, preventing memory leaks and improving performance. To create a lifecycle-aware component, developers implement the LifecycleObserver interface and use @OnLifecycleEvent to handle events. However, in newer versions, DefaultLifecycleObserver is recommended instead because @OnLifecycleEvent is now deprecated.

Get to know more with an Example: Activity Lifecycle in Android with Demo App.

2. How can Two Distinct Android Apps Interact?

On Android, there are essentially two ways for apps to communicate with one another:

• Intents - Used to pass data between apps, allowing one app to start another or request specific actions (e.g., opening a webpage or sharing content).
• Services- Enable an app to provide functionality to other apps, such as background tasks or APIs that other apps can access.

3. How would you communicate between Two Fragments?

Communication between two fragments should always go through a shared ViewModel or their hosting Activity, rather than direct interaction.

The recommended approach is to use a shared ViewModel, which is scoped to the Activity containing both fragments. Each fragment can access this ViewModel instance, allowing them to share data seamlessly. If the ViewModel exposes data via LiveData, any changes made by one fragment will automatically be observed by the other, ensuring real-time updates.

This approach promotes a loosely coupled architecture, making the app more maintainable and reducing the risk of unexpected behavior. Get to know more with an Example: How to Communicate Between Fragments in Android?

4. What is Android Data Binding?

A support library called the Data Binding Library allows you to take advantage of binding UI components to data sources in a layout using a declarative format.

Without Data Binding:

Layouts are frequently defined in activities using code that invokes UI framework APIs. For instance, in the code below, the userName field of the viewModel variable is bound to a TextView widget by calling findViewById() to locate the widget:

TextView textView = findViewById(R.id.sample_text);
textView.setText(viewModel.getUserName());

With Data Binding:

The subsequent section illustrates how to assign text to the widget directly in the layout file using the Data Binding Library. By doing this, none of the Java/Kotlin code from the previous example is necessary.

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

Advantages of using Data Binding:

1. Decreases the amount of boilerplate code - which results in less coupling, improved readability, and a custom view with a strong, simple-to-implement custom property.
2. Faster than findViewById - The binding extracts the Views with IDs in a single trip across the View Hierarchy. When using this method with several Views, findViewById may take longer.

Get to know more with an Example: Data Binding in Android with Example.

5. What is a ViewHolder Pattern? Why should We use it?

The ViewHolder pattern is a design pattern used in Android to improve the performance of list-based UI components like ListView and RecyclerView.

When the adapter calls the getView() function, it also calls the findViewById() method. As a result of the mobile CPU having to perform such heavy lifting, the application's performance suffers and battery life degrades. FindViewById shouldn't be used repeatedly. Instead, utilize the ViewHolder design pattern. The ViewHolder pattern solves this by storing references to the views, so they don’t need to be found again. By caching view references, it reduces unnecessary operations, making the UI smoother and improving overall app efficiency.

6. What is the difference between Handler, AsyncTask, and Thread?

Handler - The Handler class offers a straightforward route for sending data to this thread and can be used to register to a thread. When using another background thread, a handler enables you to connect with the UI thread.

AsyncTask - The establishment of a background process and synchronization with the main thread are both handled by the AsyncTask class. Additionally, it allows for reporting on the status of ongoing tasks.

Thread - A Thread is the core component of multithreading in Java. While it allows running background tasks, it lacks built-in support for updating the UI thread. Developers must handle synchronization, cancellation, and lifecycle changes manually.

7. Discuss Singletons vs Application Context for the app-global state.

A Singleton is a design pattern where a class has only one instance throughout the app’s lifecycle. It’s often used for caching data, managing configurations, or sharing resources. Singleton is easy to implement, persists throughout the app until the app is killed, and can be accessed anywhere. But it is harder to test and can lead to memory leaks.

The Application Context is a global context that lives as long as the app process does. It’s different from an Activity context because it’s not tied to the UI lifecycle. Application Context has no memory leaks, is good for resources like Shared Preferences and Room Database and is better testable than Singletons. But is can't store UI related elements and requires more boilerplate code than a Singleton.

User Cases:

8. How can We use AsyncTask in different Activities?

One approach is to build a callback interface using AsyncTask in several Activities.

Create a Callback Interface

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

interface AsyncTaskListener<T> {
    fun onComplete(result: T)
}

Create the JSONTask extending the AsyncTask Class

import android.os.AsyncTask;
import java.lang.ref.WeakReference;

public class JSONTask extends AsyncTask<String, Void, String> {
    private WeakReference<AsyncTaskListener<String>> listenerRef;

    public JSONTask(AsyncTaskListener<String> listener) {
        this.listenerRef = new WeakReference<>(listener);
    }

    @Override
    protected String doInBackground(String... params) {
        // Simulate network call or processing
        return "Task Completed!";
    }

    @Override
    protected void onPostExecute(String result) {
        AsyncTaskListener<String> listener = listenerRef.get();
        if (listener != null) {
            listener.onComplete(result);
        }
    }
}

import android.os.AsyncTask
import java.lang.ref.WeakReference

class JSONTask(listener: AsyncTaskListener<String>) : AsyncTask<String, Void, String>() {

    private val listenerRef = WeakReference(listener)

    override fun doInBackground(vararg params: String?): String {
        // Simulate some background work (e.g., API call)
        Thread.sleep(2000) // Simulating delay
        return "Task Completed!"
    }

    override fun onPostExecute(result: String) {
        listenerRef.get()?.onComplete(result)
    }
}

Implement in MainActivity 

public class MainActivity extends AppCompatActivity implements AsyncTaskListener<String> {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Execute AsyncTask
        new JSONTask(this).execute();
    }

    @Override
    public void onComplete(String result) {
        Toast.makeText(this, "MainActivity: " + result, Toast.LENGTH_SHORT).show();
    }
}

import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity(), AsyncTaskListener<String> {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Execute AsyncTask
        JSONTask(this).execute()
    }

    override fun onComplete(result: String) {
        Toast.makeText(this, "MainActivity: $result", Toast.LENGTH_SHORT).show()
    }
}

Implement in TestActivity

public class TestActivity extends AppCompatActivity implements AsyncTaskListener<String> {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);

        // Execute AsyncTask
        new JSONTask(this).execute();
    }

    @Override
    public void onComplete(String result) {
        Toast.makeText(this, "TestActivity: " + result, Toast.LENGTH_SHORT).show();
    }
}

import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity

class TestActivity : AppCompatActivity(), AsyncTaskListener<String> {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_test)

        // Execute AsyncTask
        JSONTask(this).execute()
    }

    override fun onComplete(result: String) {
        Toast.makeText(this, "TestActivity: $result", Toast.LENGTH_SHORT).show()
    }
}

9. What is Android Jetpack Architecture Components?

Android Jetpack provides a set of libraries that help developers build reliable, testable, and maintainable apps. It includes Android Architecture Components, which simplify common development challenges.

Architecture components:

• Data Binding: Binds UI components to data sources declaratively, reducing boilerplate code.
• Lifecycles: Manages Activity and Fragment lifecycles, preventing memory leaks and handling configuration changes.LiveData: It alerts viewers to any database modifications. Build data objects that alert views to database changes by using LiveData. Everything required for in-app navigation in an Android application is taken care of.
• LiveData: Observes and reacts to data changes, ensuring UI updates only when necessary.
• Paging: Efficiently loads large datasets in chunks, improving performance.
• Room: SQLite Object Mapping library that simplifies database interactions with compile-time checks and LiveData support.
• ViewModel: Stores and manages UI-related data in a lifecycle-aware manner, preventing data loss on configuration changes.
• WorkManager: Schedules and manages background tasks efficiently under system-defined conditions.
• Navigation: Simplifies in-app navigation, handling fragment transactions and deep linking.

Read More Here: Jetpack Architecture Components in Android.

10. What are some differences between Parcelable and Serializable?

We cannot just transfer objects to activities in Android. The objects must either implement the Serializable or Parcelable interface to accomplish this.

An established Java interface is serializable. Simply implement the Serializable interface and provide the override methods. This method's drawback is that reflection is employed, and it takes time. Serializable is substantially slower than a Parcelable operation.

This is due, in part, to the fact that we explicitly state the serialization procedure rather than letting reflection infer it. Furthermore, it makes sense that the code has been highly optimized with this end in mind.

Also:

• The serializable interface is slower than Parcelable.
• Compared to the Serializable interface, the Parcelable interface requires more effort to implement.
• You can pass a Parcelable array using Intent.
• Implementing a serializable interface is more straightforward.
• The serializable interface produces several temporary objects and significantly increases the amount of garbage collection.

11. What is Broadcast Receiver?

Broadcasts are system-wide events or messages that can occur when the device starts, when a message is received on the device, when incoming calls are received, or when a device goes to airplane mode, etc. Broadcast Receivers, a component in android, are used to respond to these system-wide events. Broadcast Receivers allow us to register for the system and application events, and when that event happens, the registered receivers get notified.

Types of Broadcast Receivers:

• Static Receivers: These types of Receivers are declared in the manifest file and work even if the app is closed. Used for system specific broadcasts.
• Dynamic Receivers: These types of receivers are declared in code and work only if the app is active or minimized. Used for app specific broadcasts.

Get to know more with an Example: Broadcast Receiver in Android With Example.

12. What is MVVM in Android?

Model—View—ViewModel (MVVM) is the industry-recognized software Architecture Pattern that overcomes all drawbacks of MVP and MVC design patterns. MVVM suggests separating the data presentation logic(Views or UI) from the core business logic part of the application. 

The separate code layers of MVVM are:

• Model: This layer is responsible for the abstraction of the data sources. Model and ViewModel work together to get and save the data.
• View: The purpose of this layer is to inform the ViewModel about the user’s action. This layer observes the ViewModel and does not contain any kind of application logic.
• ViewModel: It exposes those data streams which are relevant to the View. Moreover, it serves as a link between the Model and the View.

The description of Model is as follows:

• MODEL: (Reusable Code – DATA) Business Objects that encapsulate data and behavior of application domain, Simply hold the data. 
• VIEW: (Platform Specific Code – USER INTERFACE) What the user sees, The Formatted data. 
• VIEWMODEL: (Reusable Code – LOGIC) Link between Model and View OR It Retrieves data from Model and exposes it to the View. This is the model specifically designed for the View.

Get to know more with an Example: How to Build a Simple Note Android App using MVVM and Room Database?

13. What is the difference between getContext(), getApplicationContext(), getBaseContext(), and this?

This always refers to the current class object. getContext() is not always the same as this. For instance, in the Activity class, you can use this since Activity inherits from Context, but getContext() is not a function that is included in the Activity class.

14. What is Android Jetpack?

Android Jetpack is a set of software components, libraries, tools, and guidance to help in developing robust Android applications. Launched by Google in 2018, Jetpack comprises existing android support libraries and android architecture components with an addition of the Android KTX library as a single modular entity. Jetpack consists of a wide collection of libraries that are built in a way to work together and make robust mobile applications.

Its software components have been divided into 4 categories:

1. Foundation Components
2. Architecture Components
3. Behavior Components
4. UI Components

Key Benefits of Android Jetpack

• Forms a recommended way for app architecture through its components
• Eliminate boilerplate code
• Simplify complex task
• Provide backward compatibility as libraries like support are unbundled from Android API and are re-packaged to androidx.* package
• Inbuilt productivity feature of the Kotlin Integration

Get to know more:

• Introduction to Android Jetpack
• Jetpack Architecture Components in Android

15. What is the AndroidX Library?

AndroidX (Android Extension Library) is an open-source project that replaces the Android Support Library, offering backward compatibility and independent updates for Jetpack libraries. Unlike the Support Library, AndroidX is developed separately from the Android OS, allowing for faster improvements and better maintainability.

Key Features of AndroidX:

1. Replaces the Support Library with improved, modular packages.
2. Backward compatibility for older Android versions.
3. Independent updates—not tied to Android OS releases.
4. Part of Jetpack, improving app architecture and maintainability.
5. Uses consistent naming (androidx.* instead of android.support.*).

Additionally, AndroidX has the following functionalities as well:

• A single namespace with the letters AndroidX contains all AndroidX packages. The Support Library packages have been mapped to the equivalent androidx.* packages.
• Unlike the Support Library, AndroidX packages are individually updated and maintained. The AndroidX packages rigorously follow semantic versioning starting with version 1.0.0. The AndroidX libraries for a project can be independently updated.
• All upcoming Support Library work will take place in the AndroidX library. This covers the maintenance of the original Support Library objects as well as the creation of new Jetpack components.

16. Explain Dependency Injection.

Dependency Injection (DI) is a design pattern that manages object dependencies efficiently by providing them from an external source rather than having classes create them directly. This follows the Inversion of Control (IoC) principle, where dependencies are injected instead of being manually instantiated.

Dependency Framework is used for the following reasons:

1. Manages complex dependencies in large projects.
2. Improves testability by allowing the use of mocked objects.
3. Reduces boilerplate code by automating object creation.
4. Controls object scope and lifecycle, ensuring efficient memory management.

17. What is Singleton Class in Android?

The Singleton Pattern is a software design pattern that restricts the instantiation of a class to just “one” instance. It is used in Android Applications when an item needs to be created just once and used across the board. The main reason for this is that repeatedly creating these objects, uses up system resources. The identical object should therefore only be created once and used repeatedly. It is utilized in situations where we only require a single instance of the class, such as with network services, databases, etc. We, therefore, create a singleton class to implement the Singleton pattern in our project or product.

Key Features:

1. Prevents redundant object creation, saving memory.
2. Ensures consistent access to shared resources.
3. Useful for global objects like API clients, databases, and caches.

Get to know more with an Example: Singleton Class in Android.

18. What is Jetpack Compose in Android?

Jetpack Compose is a modern UI toolkit recently launched by Google which is used for building native Android UI. It simplifies and accelerates the UI development with less code, Kotlin APIs, and powerful tools. 

• Declarative
• Compatible
• Increase development speed
• Concise and Idiomatic Kotlin
• Easy to maintain
• Written in Kotlin

Get to know more with an Example: Basics of Jetpack Compose in Android.

19. What is Coroutine on Android?

The Kotlin team defines coroutines as “lightweight threads”. They are sort of tasks that the actual threads can execute. Kotlin coroutines introduce a new style of concurrency that can be used on Android to simplify asynchronous programming. By lightweight, it means that creating coroutines doesn’t allocate new threads. Instead, they use predefined thread pools and smart scheduling for the purpose of which task to execute next and which tasks later. Get to know more with an Example: Coroutines in Android.

20. What is Espresso in Android?

Espresso is an open-source UI testing framework developed by Google for Android apps. It allows developers to write concise, reliable, and fast UI tests by interacting with UI elements and verifying their behavior.

Features of Espresso:

1. Espresso runs tests quickly and automatically waits for the app to be ready, so you don’t need to use Thread.sleep().
2. It provides simple, readable commands to interact with the app and check if things are working.
3. It knows when the app is idle and runs tests at the right time, so you don’t have to add extra delays.
4. Easily integrates with standard testing tools to check how your app behaves.

Get to know more with an Example: UI Testing with Espresso in Android Studio.

21. Types of Notifications in Android.

Notifications could be of various formats and designs depending upon the developer. In General, one must have witnessed these four types of notifications:

1. Status Bar Notification: Appears in the same brief layout as the current time and battery percentage.
2. Notification Drawer Notification: Appears in the drop-down menu.
3. Heads-Up Notification: Appears on the overlay screen, eg: Chat App notification and OTP messages.
4. Lock-Screen Notification: Appears on the overlay of the locked screen if enabled.

Get to know more with an Example: Notifications in Android with Example.

22. What is Firebase Cloud Messaging?

Firebase Cloud Messaging or FCM, originally known as Google Cloud Messaging or GCM, is a free cloud service provided by Google that enables app developers to deliver notifications and messages to users across many platforms, including Android, iOS, and web applications. It is a free real-time method for instantly sending notifications to client applications. Notifications with a payload of up to 4Kb can be properly transmitted via Firebase Cloud Messaging.

23. What is the Google Android SDK?

The Google Android SDK is a set of tools that developers use to create apps that run on Android-enabled devices. It includes a graphical interface that simulates an Android-driven portable environment, allowing them to test and debug their applications.

24. What is the difference between Volley and Retrofit?

25. Types of Databases in Android.

Relational, key-value, and object-oriented databases are the three main types of databases used by Android devices.

1. SQLite: A well-known relational mobile database that is available on both Android and iOS.
2. ORMLite: A lightweight Object Relational Mapper or ORM designed for Java/Kotlin applications, including Android.
3. Room: An abstraction layer that sits on top of SQLite. Uses database classes as the primary access point for the persisted data and the means by which the database is maintained.
4. Firebase Cloud Firestore or Realtime Database: Comprehensive multifunctional platform with a broad variety of goods, such as Cloud Firestore and Realtime Database.
5. Realm: A quick, expandable replacement for SQLite that makes modern mobile applications' data storing, querying, and synchronizing processes simple.