Have a question?
Message sent Close

35 Essential Android Interview Questions You Need to Know

Most Commonly Asked Android Interview Questions in 2024

Q1. What is Intent in Android?
Ans: An Intent in Android is a messaging object that is used to request an action from another app component. It serves as a way to communicate between different components like activities, services, and broadcast receivers. There are two types of Intents:

  • Explicit Intent: Specifies the component to be invoked by its name.Example:
Intent explicitIntent = new Intent(this, AnotherActivity.class);
  • Implicit Intent: Specifies the action to be performed, and the system decides which component can best handle that action.


Intent implicitIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.example.com"));

Q2. What’s the difference between onCreate() and onStart()?

  • onCreate(): It is called when the activity is first created. This is where initialization and UI setup should happen.Example:
protected void onCreate(Bundle savedInstanceState) {
    // Initialize UI elements and variables here
  • onStart(): It is called when the activity becomes visible to the user. This is often used for actions that need to happen every time the activity is brought into the foreground.


protected void onStart() {
    // Perform actions when the activity is visible to the user

Q3. What are the lifecycle methods of Android activity and what is their purpose?
Ans: The key lifecycle methods of an Android activity are:

  • onCreate(): Initialization and UI setup.
  • onStart(): Activity becomes visible.
  • onResume(): Activity is interacting with the user.
  • onPause(): Another activity is taking focus.
  • onStop(): Activity is no longer visible.
  • onDestroy(): Activity is being destroyed.

These methods allow developers to manage resources, handle UI changes, and save and restore data as the app moves through different states.

Q4. What is the difference between an interface and an abstract class?

  • Abstract Class:
    • Can have both abstract and concrete methods.
    • Can have instance variables.
    • Supports constructors.
    • A class can extend only one abstract class.
  • Interface:
    • Can only have abstract methods (before Java 8).
    • Cannot have instance variables (before Java 8).
    • No constructors allowed.
    • A class can implement multiple interfaces.

Q5. What is the relationship between the lifecycle of an AsyncTask and an Activity? What problems can this result in? How can these problems be avoided?

  • Relationship: AsyncTask is often used for background tasks in an activity. However, if the activity is destroyed and the AsyncTask is still running, it can lead to memory leaks or crashes.
  • Problems:
    • AsyncTask may hold references to the destroyed activity.
    • UI updates in onPostExecute() can fail if the activity is gone.
  • Avoidance:
    • Use WeakReference to the activity.
    • Cancel the AsyncTask in onDestroy().


public class MyTask extends AsyncTask<Void, Void, Void> {
    private WeakReference<MainActivity> activityReference;
    MyTask(MainActivity context) {
        activityReference = new WeakReference<>(context);
    // doInBackground() and onPostExecute() implementations...

Q6. What is an Application Not Responding (ANR) error, and how can you prevent them from occurring in your app?

  • ANR Error:
    • ANR occurs when the main thread of an application is blocked for too long.
    • This can happen due to lengthy operations on the main thread, like network requests.
  • Prevention:
    • Perform network operations on a separate thread or use AsyncTask.
    • Use background services for long-running tasks.
    • Optimize code to avoid blocking the main thread.

Q7. Explain in brief about the important file and folder when you create a new android application.
Ans: When you create a new Android application, some important files and folders include:

  • res/: Contains resources such as layouts, drawables, and values.
  • src/: Contains Java source code organized into packages.
  • AndroidManifest.xml: Describes the structure and metadata of the application.
  • build.gradle: Configuration file for Gradle build system.
  • app/: Module-specific resources and code.

Q8. What Security measures should you take to prevent reverse engineering on your APK?
Ans: To prevent reverse engineering on your APK, consider the following measures:

  • Obfuscation: Use tools like ProGuard to obfuscate the code, making it harder to reverse engineer.
  • Code Encryption: Encrypt sensitive parts of your code.
  • License Verification: Implement license checks to prevent unauthorized usage.
  • Tamper Detection: Implement checks to detect tampering with the APK.

Q9. Are SQL Injection attacks valid in Android? How would you prevent them?

  • SQL Injection in Android:
    • Yes, SQL Injection attacks are possible if not handled properly.
    • User input should be validated and sanitized before using it in SQL queries.
  • Prevention:
    • Use parameterized queries or prepared statements.
    • Avoid concatenating user input directly into SQL queries.
    • Implement input validation and sanitize user input.


String userInput = "userInput";
String query = "SELECT * FROM table WHERE column = ?";
Cursor cursor = database.rawQuery(query, new String[]{userInput});

Q10. What is Dependency Injection?

  • Dependency Injection (DI):
    • DI is a design pattern where components are provided with their dependencies rather than creating or looking for them.
    • It promotes loose coupling and easier testing.


public class MyActivity extends AppCompatActivity {
    private ApiService apiService;

    public MyActivity(ApiService apiService) {
        this.apiService = apiService;

Q11. What kind of tests can you write to test your Android application?

  • Unit Tests: Test individual components in isolation.
  • Integration Tests: Test the interaction between components.
  • UI Tests: Test the application’s user interface and user interactions.
  • Instrumentation Tests: Test components with access to the Android framework.

Q12. How does RecyclerView differ from ListView?

  • RecyclerView:
    • More flexible and efficient.
    • Uses a LayoutManager for positioning items.
    • Supports horizontal and vertical scrolling.
    • Requires a ViewHolder pattern.
  • ListView:
    • Less flexible and efficient.
    • Uses an Adapter to manage data.
    • Limited support for complex layouts.
    • No built-in support for animations.

Q13. What is a memory leak?

  • Memory Leak:
    • A memory leak occurs when an application allocates memory but fails to release it.
    • Over time, this can lead to increased memory usage and performance issues.

Q14. What does the keyword synchronized mean?

  • synchronized:
    • In Java, it is used to control access to critical sections of code by multiple threads.
    • It ensures that only one thread can access the synchronized block at a time.


synchronized (lockObject) {
    // Critical section of code

Q15. Explain AndroidManifest.xml file and why do you need this?

  • AndroidManifest.xml:
    • It is a configuration file that describes essential information about the app.
    • It contains metadata, permissions, activities, services, receivers, etc.
    • Required for the Android system to understand the app’s structure and behavior.

Q16. What is the difference between Serializable and Parcelable? Which is the best approach in Android?

  • Serializable:
    • Java interface for object serialization.
    • Slower and creates a lot of temporary objects.
  • Parcelable:
    • Android-specific interface for efficient serialization.
    • Faster and creates fewer temporary objects.

Best Approach:

  • Parcelable is preferred in Android due to its efficiency, especially in scenarios like passing data between activities.

Q17. Describe Android Activities in brief.

  • Activity:
    • An activity represents a single, focused task that a user can do.
    • It serves as a window where the user interacts with the app.
    • Activities can be part of a larger task and can be started, paused, resumed, and stopped.

Q18. How would you launch an ActivityB from ActivityA and clear the back stack of activities when the new activity is called?

Intent intent = new Intent(ActivityA.this, ActivityB.class);
finish(); // Optional: finish ActivityA to remove it from the back stack

Q19. Write some code example that will cause a Java memory leak.

public class MemoryLeakActivity extends AppCompatActivity {
    private static List<Context> contextList = new ArrayList<>();

    protected void onCreate(Bundle savedInstanceState) {
        contextList.add(this); // Causes a memory leak

In this example, the MemoryLeakActivity keeps a reference to itself in a static list, preventing it from being garbage collected.

Q20. What is the difference between Service and IntentService? How is each used?

  • Service:
    • A generic base class for services that run in the background.
    • Runs on the main thread, so you need to handle threading manually.
    • Suitable for long-running tasks.
  • IntentService:
    • A subclass of Service that handles asynchronous requests using a worker thread.
    • Automatically stops itself when the work is done.
    • Suitable for short-lived, one-off tasks.

Q21. Describe Intents in detail.

  • Intent:
    • An Intent is a messaging object used to request an action from another app component.
    • It can be explicit (targeting a specific component) or implicit (specifying the action, and the system decides the component).
    • Used for starting activities, services, and broadcasting messages.

Q22. What are the different data storage options available on the Android platform?

  • Shared Preferences: Simple key-value pairs.
  • Internal Storage: Private storage space for the app.
  • External Storage: Public storage like SD card.
  • SQLite Database: Local relational database.
  • Network Connection: Store data remotely.
  • Cloud Storage: Use cloud services for storage.

Q23. How do you supply construction arguments into a Fragment?

  • Use a static method to create a new instance of the fragment and supply arguments using a Bundle.


public class MyFragment extends Fragment {
    public static MyFragment newInstance(String argument) {
        MyFragment fragment = new MyFragment();
        Bundle args = new Bundle();
        args.putString("key", argument);
        return fragment;
    // Access arguments in onCreate() using getArguments()

Q24. How to send SMS in Android? Explain with an example.

// Add permission in AndroidManifest.xml
<uses-permission android:name="android.permission.SEND_SMS" />

// Code to send SMS
String phoneNumber = "1234567890";
String message = "Hello, this is a test SMS!";
SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage(phoneNumber, null, message, null, null);

Q25. How to create an application that supports different screen sizes?

  • Use responsive layouts and flexible designs.
  • Provide alternative resources (drawables, layouts) for different screen densities and sizes.
  • Use size-qualifiers and density-qualifiers in resource folders (e.g., layout-large, drawable-hdpi).
  • Test on various devices and emulators with different screen sizes.

Q26. What is a Broadcast receiver?

  • A Broadcast Receiver is an Android component that responds to system-wide broadcast announcements.
  • It acts as an event listener that reacts to events such as incoming SMS, device boot, etc.
  • Register a receiver in the manifest or dynamically in code.

Q27. Describe the SmsManager class in Android.

  • SmsManager is a class in Android that provides methods to send SMS messages.
  • It is part of the android.telephony package.
  • Use sendTextMessage() to send a simple text SMS.

Q28. Can you mention some of the characteristics of the Object-Oriented Programming (OOP) languages?

  • Encapsulation: Bundling data and methods that operate on the data.
  • Inheritance: Creating new classes based on existing classes.
  • Polymorphism: Ability to use a single interface for different data types or objects.
  • Abstraction: Simplifying complex systems by modeling classes based on real-world entities.

Q29. Imagine you need to create an Android app that supports multiple languages and cultures, what’s the best approach for you to do this?
Ans: To support multiple languages and cultures in an Android app, the best approach is to use the localization and internationalization features provided by Android. Here’s a step-by-step guide:

  1. Use Resource Files: Store all user-facing strings in resource files. Create separate resource files for each language. For example, res/values/strings.xml for the default language and res/values-es/strings.xml for Spanish.
  2. String Localization: Replace hardcoded strings in your code with references to the resource files. Use the R.string references to access strings dynamically.


// Original code
String greeting = "Hello, World!";

// Localized code
String greeting = getString(R.string.hello_world);
  1. Locale Configuration: Android will automatically select the appropriate resource based on the user’s device locale. You can also programmatically set the locale based on user preferences.


// Set locale programmatically
Resources resources = getResources();
Configuration configuration = resources.getConfiguration();
resources.updateConfiguration(configuration, resources.getDisplayMetrics());

By following these steps, your app will dynamically adapt its language and cultural settings based on the user’s device or preferences.

Q30. What are Views and View Groups, and what’s the difference between them?

  • Views: Views are the basic building blocks of the Android user interface. They are UI elements that users can interact with, such as buttons, text fields, and images.
  • View Groups: View Groups are containers that hold and organize multiple views. They define the layout structure of the user interface. Examples include LinearLayout, RelativeLayout, and ConstraintLayout.


  • Views are the individual UI components like buttons or text fields.
  • View Groups are containers that hold multiple views and define their layout.


<!-- View Group (LinearLayout) containing two Views (Button) -->

        android:text="Button 1"/>

        android:text="Button 2"/>

In this example, LinearLayout is a View Group containing two Buttons (Views).

Q31. How can you use built-in Messaging within your application?
Ans: To implement messaging within an Android application, you can use the built-in Intent system to launch the device’s messaging app. Here’s an example:


// Assuming you have a button in your layout with an onClick attribute
public void sendMessage(View view) {
    Intent intent = new Intent(Intent.ACTION_SENDTO);
    intent.setData(Uri.parse("smsto:" + Uri.encode("1234567890"))); // Replace with the recipient's phone number
    intent.putExtra("sms_body", "Hello, this is a test message.");

    if (intent.resolveActivity(getPackageManager()) != null) {
    } else {
        // Handle the case where the messaging app is not available
        Toast.makeText(this, "Messaging app not installed", Toast.LENGTH_SHORT).show();

This example uses an implicit intent to open the messaging app, pre-filling the recipient’s number and a default message.

Q32. Describe SharedPreference storage option with an example.
Ans: SharedPreferences is a way to store simple data in key-value pairs persistently. It’s often used for storing user preferences or settings. Here’s an example:


// Save data to SharedPreferences
SharedPreferences preferences = getSharedPreferences("myPrefs", MODE_PRIVATE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("username", "JohnDoe");
editor.putInt("userAge", 25);

// Retrieve data from SharedPreferences
String username = preferences.getString("username", "DefaultUsername");
int userAge = preferences.getInt("userAge", 0);

// Use the retrieved data
Log.d("SharedPreferencesExample", "Username: " + username + ", Age: " + userAge);

In this example, data (username and age) is stored using the SharedPreferences.Editor. The data can later be retrieved using the same keys. The second parameter in the getString and getInt methods represents the default value in case the key is not found.

Q33. What are the key components of Android Architecture?
Ans: The key components of Android Architecture include:

  1. Linux Kernel: Provides a core set of functions, including security, memory management, process management, and device drivers.
  2. Hardware Abstraction Layer (HAL): Acts as a bridge between the Android system and the device-specific hardware, enabling communication with camera, Bluetooth, Wi-Fi, etc.
  3. Native Libraries: Essential libraries for various functionalities, such as SQLite for database management, WebKit for web rendering, and OpenGL ES for 2D/3D graphics.
  4. Android Runtime (ART/Dalvik): The runtime environment responsible for running and managing Android applications.
  5. Application Framework: Provides high-level building blocks for app development, including activities, services, content providers, and broadcast receivers.
  6. System Apps: Pre-installed apps that come with the Android system, like the phone dialer, contacts, and settings.
  7. Application Layer: The layer where user-installed applications reside, providing the user interface and user experience.

Q34. Tell us something about activityCreator?
Ans: As of my knowledge cutoff in January 2022, there isn’t a standard component or tool called “activityCreator” in the Android framework. It’s possible that new features or tools have been introduced since then, or the term might refer to a specific library or tool created by a third party.

If you have more context or details about “activityCreator,” I could provide more accurate information. Otherwise, it’s advisable to refer to the official Android documentation or the source where you encountered this term for the latest and most accurate information.

Q35. What is AIDL?
Ans: AIDL (Android Interface Definition Language): AIDL is a language used to define the interface requirements between client and service components in Android. It is used for interprocess communication (IPC) in situations where different components (often running in different processes) need to communicate with each other.

Example: Suppose you have a service that performs calculations, and you want to allow other apps to use this service. You define the interface using AIDL, specifying methods that clients can invoke.

// Example AIDL file
// CalculatorService.aidl
interface ICalculatorService {
    int add(int num1, int num2);
    int subtract(int num1, int num2);

Click here for more Android related topics.

To know more about Android please visit Android official site.

1 Comment

  • Wow, awesome blog format! How long have you been running a blog for?
    you made blogging look easy. The whole glance
    of your site is excellent, let alone the content! You can see similar: e-commerce and here sklep

Leave a Reply