Top 113 Android Interview Questions And Answers

Question 1

What is a difference between `Spannable` and `String`?

Accepted Answer

A **Spannable** allows to attach formatting information like bold, italic, ... to sub-sequences ("spans", thus the name) of the characters. It can be used whenever you want to represent **rich text**.

Question 2

What is an `Activity`?

Accepted Answer

An **Activity** provides the window in which the app draws its UI.

This window typically fills the screen, but may be smaller than the screen and float on top of other windows. Generally, **one activity implements one screen** in an app. For instance, one of an app’s activities may implement a Preferences screen, while another activity implements a Select Photo screen.

Question 3

What is the difference between `Bitmap` and `Drawable` in Android?

Accepted Answer

* A **Bitmap** is a representation of a bitmap image (something like java.awt.Image).
* A **Drawable** is an abstraction of "something that can be drawn". It could be a Bitmap (wrapped up as a BitmapDrawable), but it could also be a solid color, a collection of other Drawable objects, or any number of other structures.

Question 4

Mention the difference between `RelativeLayout` and `LinearLayout`?

Accepted Answer

* **Linear Layout** — Arranges elements either vertically or horizontally. i.e. in a row or column.
* **Relative Layout** — Arranges elements relative to parent or other elements.

Question 5

Explain activity lifecycle

Accepted Answer

As a user navigates through, out of, and back to your app, the Activity instances in your app transition through different states in their lifecycle.

To navigate transitions between stages of the activity lifecycle, the Activity class provides a core set of six callbacks: `onCreate()`, `onStart()`, `onResume()`, `onPause()`, `onStop()`, and `onDestroy()`. The system invokes each of these callbacks as an activity enters a new state.

![](https://developer.android.com/guide/components/images/activity_lifecycle.png)

Question 6

How to persist data in an Android app?

Accepted Answer

There are basically four different ways to store data in an Android app:

1. Shared Preferences - to save primitive data in key-value pairs
2. Internal Storage - you need to store data to the device filesystem, but you do not want any other app (even the user) to read this data
3. External Storage -  you might want the user to view the files and data saved by your app
4. SQLite database

Question 7

How do I pass data between Activities in Android application?

Accepted Answer

The easiest way to do this would be to pass the session id to the signout activity in the **Intent** you're using to start the activity:

```java
Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);
```
Access that intent on next activity:
```java
String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");
```

Question 8

What is an `AsyncTask`?

Accepted Answer

`AsyncTask` is one of the easiest ways to implement parallelism in Android without having to deal with more complex methods like Threads. Though it offers a basic level of parallelism with the UI thread, it should not be used for longer operations (of, say, not more than 2 seconds).

AsyncTask has four methods

- `onPreExecute()` 
- `doInBackground()`
- `onProgressUpdate()`
- `onPostExecute()`

where `doInBackground()` is the most important as it is where background computations are performed.

Question 9

What is _Dalvik_?

Accepted Answer

**Dalvik** is a **Just In Time (JIT)** compiler.

By the term JIT, we mean to say that whenever you run your app in your mobile device then that part of your code that is needed for execution of your app will only be compiled at that moment and rest of the code will be compiled in the future when needed. The JIT or Just In Time compiles only a part of your code and it has a smaller memory footprint and due to this, it uses very less physical space on your device.

Question 10

What is _ADB_ and what is it used for?

Accepted Answer

**ADB** is the acronym for **Android Debug Bridge**, which is part of the Android SDK (Software Development Kit). It uses a client-server-model (i.e. adbd, the ADB daemon, is running on the device and can be connected to), and in most cases is used via an USB connection. It is also possible to use it via WiFi (wireless adb).

There's nothing you need to install on your Android device, as the ADB daemon (adbd) is already integrated into the Android OS. It is usually accessed via a command line interface from the PC, where either the full Android SDK is installed (several 30 MB download archive currently), or a massively stripped-down version for "non-developers", sometimes referred to as "Mini ADB" or "ADB essentials" (for Linux, this is only the adb executable; for Windows it's adb.exe plus two or three .dll files).

Top 113 Android Interview Questions

What is a difference between Spannable and String?

What is an Activity?

Mention the difference between RelativeLayout and LinearLayout?

What is the difference between Bitmap and Drawable in Android?

What is Context on Android?

How to persist data in an Android app?

What is an AsyncTask?

Explain the build process in Android

What is ADB and what is it used for?

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

What is the most appropriate way to store user settings in Android application?

In what situation should one use RecyclerView over ListView?

What is View Group? How are they different from Views?

Explain Android notification system

How can I get the context in a Fragment?

What types of Context do you know?

What is Armv7?

What is the Dalvik Virtual Machine?

How does the OutOfMemory happens?

What is an Intent in Android?

Tell about Constraint Layout

What is a ContentProvider and what is it typically used for?

Explain activity lifecycle

Why is it recommended to use only the default constructor to create a Fragment?

Explain briefly all the Android application components

How do I pass data between Activities in Android application?

Is it possible to implement the Model–View–Controller pattern in Java for Android?

What is Dalvik?

Explain key differences between Service and IntentService

What is the difference between onCreate() and onCreateView() lifecycle methods in Fragment?

What is a JobScheduler?

When to use Fragments vs Activities?

What are the differences between onCreate(), onCreateView(), and onActivityCreated() in Fragments and what would they each be used for?

What is a LocalBroadcastManager?

What is the difference between Service & Intent Service?

What is the difference between Handler vs AsyncTask vs Thread?

What is Handler and what is it used for?

What are the differences between ArrayList and ArrayMap?

What is the difference between AsyncTask and Thread/Runnable?

What are Retained Fragments?

What is the difference between Activity and Context?

What is Android Data Binding?

Explain how HashMap works

What are the permission protection levels in Android?

What is RenderScript and when should we (really) use it?

What are dex files are used for?

Describe different types of Services in Android

What is the difference between ListView and RecyclerView?

What is an Android PendingIntent?

Android Log.v(), Log.d(), Log.i(), Log.w(), Log.e(). When to use each one?

What is the actual differences between a Activity Context and Application Context?

What is ART?

How would you communicate between two Fragments?

Explain String vs StringBuilder vs SpannedString vs SpannableString vs SpannableStringBuilder vs CharSequence?

When to use Android's ArrayMap instead of a HashMap?

How can two distinct Android apps interact?

Why Fragments, and when to use Fragments instead of Activities?

What is the difference between a Bundle and an Intent?

What is Explicit Intent?

What is Implicit Intent?

What is the difference between Adapter and Loader in Android?

What is Intent Filter?

What is Parcelable in Android?

What is the difference between compileSdkVersion and targetSdkVersion?

What are Android Annotations and what are they used for?

How to declare Global variables in Android?

What is the Support Library? Why was it introduced?

What does LayoutInflater in Android do?

How could you pass data between activities without Intent?

When to use Android Loaders?

What is DDMS and what can you do with it?

How would you support different screen sizes?

What is the difference between invisible and gone for the View visibility status?

Isn't Android's Bundle functionally equivalent with a Map?

Can you manually call the Garbage collector?

Why to consider FlatBuffers over JSON?

What are some difference between Parcelable and Serializable?

What is the difference between Android Timer and a Handler to do action every N seconds?

Provide some tips to reduce battery usage in an android application

What is a difference between `Spannable` and `String`?

What is an `Activity`?

Mention the difference between `RelativeLayout` and `LinearLayout`?

What is the difference between `Bitmap` and `Drawable` in Android?

What is `Context` on Android?

What is an `AsyncTask`?

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

In what situation should one use `RecyclerView` over `ListView`?

How can I get the `context` in a Fragment?

What types of `Context` do you know?

How does the `OutOfMemory` happens?

What is an `Intent` in Android?

What is a `ContentProvider` and what is it typically used for?

Why is it recommended to use only the default constructor to create a `Fragment`?

Explain key differences between `Service` and `IntentService`

What is the difference between `onCreate()` and `onCreateView()` lifecycle methods in `Fragment`?

What is a `JobScheduler`?

When to use `Fragment`s vs `Activitie`s?

What are the differences between `onCreate()`, `onCreateView()`, and `onActivityCreated()` in Fragments and what would they each be used for?

What is a `LocalBroadcastManager`?

What is the difference between `Service` & `Intent Service`?

What is the difference between `Handler` vs `AsyncTask` vs `Thread`?

What is `Handler` and what is it used for?

What are the differences between `ArrayList` and `ArrayMap`?

What is the difference between `AsyncTask` and `Thread/Runnable`?

What is the difference between `Activity` and `Context`?

Explain how `HashMap` works

What are `dex` files are used for?

What is the difference between `ListView` and `RecyclerView`?

What is an Android `PendingIntent`?

Android `Log.v()`, `Log.d()`, `Log.i()`, `Log.w()`, `Log.e()`. When to use each one?

Explain `String` vs `StringBuilder` vs `SpannedString` vs `SpannableString` vs `SpannableStringBuilder` vs `CharSequence`?

When to use Android's `ArrayMap` instead of a `HashMap`?

What is the difference between a `Bundle` and an `Intent`?

What is the difference between `Adapter` and `Loader` in Android?

What is `Parcelable` in Android?

What is the difference between `compileSdkVersion` and `targetSdkVersion`?

What does `LayoutInflater` in Android do?

How could you pass data between activities without `Intent`?

What is the difference between `invisible` and `gone` for the `View` visibility status?

Isn't Android's `Bundle` functionally equivalent with a `Map`?

Why to consider `FlatBuffers` over `JSON`?

What are some difference between `Parcelable` and `Serializable`?

What is the difference between Android `Timer` and a `Handler` to do action every `N` seconds?

What is a `ThreadPool`? And is it more effective than using several separate `Threads`?

What is the difference between `ArrayMap` vs `HashMap`?

Explain how `ArrayMap` works

When to use `SparseArray` vs `HashMap`?

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

When is it necessary, or better to use a `SurfaceView` instead of a `View`?

What is a `Sticky Broadcast`?

What is the `StrictMode`?

Discuss `Singletons` vs. `Application Context` for app-global state

What is the difference between `Local`, `Normal`, `Ordered` and `Sticky` broadcasts?

What is the relationship between `Looper`, `Handler` and `MessageQueue` in Android?

What is `Intent` vs `Sticky Intent` vs `Pending Intent`?

What happens if the user navigates away or closes the app while I still have a reference to the `Activity` the user just closed in my `AsyncTask`?

Explain when would you call `getApplicationContext()` and why?

Explain reasons why not to use `getApplicationContext()`?

What is the `onTrimMemory` method?

What is the `ViewHolder` pattern? Why should we use it?

How can I use `AsyncTask` in different Activities?