1.

What is the difference

between a fragment and an
activity in Android?
In Android, an activity represents a single screen with a user interface with
which the user can interact, while a fragment represents a portion of an
activity's user interface or behavior that can be reused across multiple
activities.

The key difference between an activity and a fragment is that an activity can
exist independently and be launched independently, while an activity must
host a fragment. A single activity can host multiple fragments, and each
fragment can be added, removed, or replaced at Android runtime based on
the user's interaction.

Another difference is that an activity has a life cycle of its own, while a
fragment depends on its hosting activity's life cycle. When the hosting
activity is destroyed, all its associated fragments are also destroyed.

Fragments are often used to create modular and flexible user interfaces,
where different portions of the UI can be added or removed based on the
device's screen size or the user's interaction. Fragments can also
communicate with their hosting activity and other fragments through
interfaces, making it easier to create loosely coupled and reusable
components in an Android application.
2. What is the importance of
the AndroidManifest.xml file
in an Android application?
The AndroidManifest.xml file is a key component of an Android application.
It is an XML file that provides essential information about the application to
the Android operating system. Some of the important roles that the
AndroidManifest.xml file in the Android SDK plays are:
• Declaring the application's package name: The package name is a
unique identifier for the application, and it is used to distinguish it
from other applications installed on the device.

• Declaring the application's components: The manifest file declares

all the components of the application, including activities, services,
broadcast receivers, and content providers. The Android OS uses this
information to launch and manage these components.

• Declaring the required permissions: The AndroidManifest.xml file

lists all the permissions that the application requires to access system
resources or other applications' data. When the application is
installed, users are prompted to grant these permissions.

• Declaring the application's minimum and target API levels: The

manifest file specifies the application's minimum Android API level
required to run and the target API level the application is built for.

• Declaring the application's launch activity: The manifest file

specifies which activity should be launched when the application is
launched.

Overall, the AndroidManifest.xml file is crucial to an Android application's

functionality and security. It provides the Android system with all the
necessary information about the application, enabling it to launch and
manage its components and enforce security measures for your Android
device.

related:

best android IDEs: 5 options from senior developer you

should pay attention toread more

3. How do you implement

data binding in an Android
application?
Data binding is a powerful feature in Android mobile application software
development that allows you to bind UI components in your layout files to
data sources in your app, such as a ViewModel or model object. This can
help simplify your code, reduce boilerplate, and make your app more
efficient. Here are the steps to implement data binding in an Android
application:

1. Enable data binding in your app: To use data binding in your app, you
need to enable it in the app's build.gradle file by adding the following lines:
android {
...
dataBinding {
enabled = true
}
}

2. Create a layout file with data binding: In your layout file, wrap your root
view with the <layout> tag. This enables data binding for the layout file and
allows you to use binding expressions to bind UI components to data
sources. For example:
<layout xmlns:android="http://schemas.android.com/apk/res/android">
 <LinearLayout ...>
<TextView
android:id="@+id/textView"
android:text="@{viewModel.text}" />
</LinearLayout>
</layout>

3. Create a data source: In your activity or fragment, create a data source,

such as a ViewModel or model object, that contains the data to be
displayed in the UI components. For example:
class MyViewModel : ViewModel() {
val text = MutableLiveData<String>("Hello, World!")
}

4. Bind the data to the UI components: In your activity or fragment, inflate

the layout file using DataBindingUtil.inflate() and bind the data source to
the layout using the generated binding class. For example:
val binding: MyLayoutBinding = DataBindingUtil.inflate(
inflater, R.layout.my_layout, container, false)
binding.viewModel = MyViewModel()

5. Update the data source: To update the data displayed in the UI

components, update the properties of the data source. This will
automatically update the bound UI components. For example:
viewModel.text.value = "Hello, Data Binding!"

In summary, to implement data binding in an Android project, you need to

enable data binding in your app, create a layout file with data binding
expressions, create a data source to hold the data to be displayed, bind the
data source to the UI components in the layout, and update the data
source to update the UI components.

4. What is the difference

between an implicit and an
explicit intent in Android?
In Android, intents are a way to communicate between different
components of an application and between different applications. They are
used to request an action from the system, such as opening a specific
activity, sending a message, or sharing data.

There are two types of intent in Android: implicit intent and explicit intent.

An explicit intent specifies the component to be invoked by providing the

name of the class to be instantiated. This type of intent is used to launch a
specific component within the same application. Explicit intents are typically
used to launch a new activity within the same application, start a service, or
broadcast a message within the same application.

For example, suppose an application has two activities, Activity A and

Activity B, and Activity A wants to launch Activity B. In that case, it can
create an explicit intent that specifies the name of the Activity B class.

On the other hand, an implicit intent does not specify the exact
component to be invoked. Instead, it specifies an action to be performed
and the data involved in the action. Implicit intents are typically used to
perform system-level actions, such as sending an email, making a phone
call, or browsing the web.

For example, if an application wants to allow the user to view a web page, it
can create an implicit intent that specifies the action as ACTION_VIEW and
the data as the URL of the web page. The Android system then checks the
available applications that can handle the ACTION_VIEW action and data
type, and presents the user with a list of options.

In sum, explicit intents are used to launch specific components within an

application, while implicit intents are used to perform actions on data that
other applications can handle.

test yourself in a tech interview with us

Ready for a real-life test of your skills? Send us your CV, pass prescreening, and get invited
to a tech interview with our top experts at EPAM Anywhere.
yes, find me a job
5. How do you handle
configuration changes like
screen rotations in an
Android application?
When a configuration change occurs in an Android application, such as a
screen rotation or a language change, the Android system destroys and
recreates the activity. This process can lead to loss of data and affect the
user experience. To handle configuration changes in an Android platform,
you can use one or more of the following techniques:
• Save and restore instance state: The onSaveInstanceState() method
of the activity is called before the activity is destroyed. You can use
this method to save the current state of the activity, such as the
values of UI components or any other important data, in a bundle
object. The bundle is then passed to the onCreate() method of the
activity when it is recreated, and you can use the values from the
bundle to restore the state of the activity.

• Use the ViewModel: ViewModel is a component of the Android

Architecture Components library that helps you to manage UI-related
data in a life-cycle-conscious way. You can store the data in the
ViewModel, and it will survive configuration changes because it is not
tied to the activity's life cycle.

• Handle configuration changes manually: You can prevent the

activity from being destroyed and recreated on configuration
changes by specifying the android:configChanges attribute in the
activity tag of the AndroidManifest.xml file. This attribute tells the
system to handle the configuration change manually, and the
activity's onConfigurationChanged() method will be called instead of
the recreated activity.
In summary, handling configuration changes in an Android application
requires preserving and restoring important data to prevent data loss and
ensure a good user experience. To achieve this, you can use techniques
such as saving and restoring instance state, using ViewModel, using
retained fragments, or handling configuration changes manually.

6. What are the different

types of layouts available in
Android, and when would
you use each one?
In Android, layouts arrange user interface components in an activity or a
fragment. Several types of layouts are available in Android, each with a
specific purpose. The most commonly used layouts are:
• LinearLayout: This layout arranges its child views either horizontally
or vertically. You would use it to create a simple layout with only one
row or column.

• FrameLayout: This layout places its child views on top of one

another. You would use it to create a simple layout with only one
child view visible at a time, such as a splash screen or a loading
screen.

• ConstraintLayout: This layout arranges its child views relative to each

other using constraints. It is a flexible and powerful layout that can
handle complex UI designs. You would use it to create a complex
layout with views positioned relative to each other.
 • TableLayout: This layout arranges child views in rows and columns,
similar to an HTML table. You would use it when you want to create a
layout with a grid-like structure, such as a calendar or a data table.

• GridLayout: This layout arranges its child views in a grid-like

structure, similar to the TableLayout but more flexible. You would use
it to create a layout with a grid-like structure that is more flexible
than a TableLayout.

• CoordinatorLayout: This layout is designed to coordinate the

interactions between child views, such as scrolling and animations.
You would use it to create a layout with complex interactions
between child views.

In sum, choosing the right layout for your Android application depends on
the complexity and requirements of the UI design.

related:

6 senior Android developer interview questions and

answersread more

7. What dialog boxes are

supported on Android?
Android provides several types of dialog boxes that you can use to interact
with users and display important information. Here are some commonly
used dialog box types supported on Android:
• AlertDialog: AlertDialog is a versatile dialog box that can display a
title, message, and optional buttons. It is often used to prompt users
for confirmation, display important information, or ask for user input.
 • ProgressDialog: ProgressDialog is a dialog box that shows the
progress of a long-running operation. It typically displays a spinning
progress indicator and an optional message to inform the user about
the ongoing task.

• DatePickerDialog: DatePickerDialog allows users to select a date

from a calendar. It provides a calendar interface for choosing a
specific date and returns the selected date to the application.

• TimePickerDialog: TimePickerDialog allows users to select a time

from a clock interface. It provides a clock-like interface for choosing
hours and minutes and returns the selected time to the application.

• BottomSheetDialog: BottomSheetDialog is a dialog that slides up

from the bottom of the screen, partially covering the content. It is
commonly used for displaying additional options or actions related to
the current context.

• Custom Dialogs: Android also allows you to create custom dialog

boxes by extending the Dialog or DialogFragment class. This gives
you full control over the appearance and behavior of the dialog,
allowing you to design a dialog that suits your specific needs.

These are just a few examples of the dialog boxes supported on Android.
Each dialog box type has its own purpose and can be customized to fit your
application's requirements. Dialog boxes are an important component in
Android user interfaces, providing a way to present information, gather user
input, and enhance the user experience.

related:

Android developer resume examplesread more

8. What is the Android
application life cycle, and
how do you handle each
stage?
The Android application life cycle refers to the stages an Android
application goes through from the time it is first launched until it is stopped
or destroyed. The main stages of the Android application life cycle are as
follows:
1. onCreate(): This is the first method that is called when the
application is launched. This method is used to initialize the
application and set up any required resources.

2. onStart(): This method is called after onCreate() and is used to

prepare the application to be visible to the user.

3. onResume(): This method is called when the application is about to

start interacting with the user. This is where the application is in the
foreground and actively running.

4. onPause(): This method is called when the application is about to

move into the background. This is a good place to save any unsaved
data or release any resources that are no longer needed.

5. onStop(): This method is called when the application is no longer

visible to the user. This is a good place to release any resources that
are no longer needed.

6. onDestroy(): This method is called when the application is

destroyed. This is a good place to release any resources not released
during the onStop() or onPause() methods.
 7. onRestart(): This method is called when the application has been
stopped before being started again.

To handle each stage of the Android application life cycle, you can override
the corresponding method in your activity or service and implement any
necessary functionality. For example, in the onCreate() method, you can
initialize any resources required for the application to run, such as database
connections or network sockets. In the onPause() method, you can save any
unsaved data or release any resources that are no longer needed to
conserve memory. In the onDestroy() method, you can release any
resources that were not released during the onPause() or onStop()
methods, such as file handles or network connections. By properly handling
each stage of the application life cycle, you can ensure that your application
runs smoothly and does not use more resources than necessary.

9. How do you implement

localization in an Android
application?
Localization is the process of adapting an application to different
languages, cultures, and regions. To implement localization in an Android
application, follow these steps:

1. Create a new values directory for each language and region that you
want to support. For example, you can create a values directory for English
(en), a values directory for French (fr), and so on. Each values directory
should contain a strings.xml file that contains the translated text for the
application.

2. Add the translated text to the strings.xml file in each values directory. For
example, if you have a button with the text "Submit" in your application,
you can add a string resource for each language in the corresponding
strings.xml file. In the English strings.xml file, you can add the following
string resource:
<string name="submit_button_text">Submit</string>

In the French strings.xml file, you can add the following string resource:
<string name="submit_button_text">Soumettre</string>

3. Use the string resources in your application's layout and code. Instead of
hard-coding the text in your application, you can reference the string
resource in the corresponding strings.xml file. For example, you can use the
following code to set the text of a button to the "submit_button_text" string
resource:
<Button
android:id="@+id/submit_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/submit_button_text" />

4. Set the default language and region for the application. You can do this
in the AndroidManifest.xml file. For example, you can add the following line
to the application tag to set the default language to English:
<application
android:label="@string/app_name"
android:icon="@drawable/app_icon"
android:allowBackup="true"
android:supportsRtl="true"
android:theme="@style/AppTheme"
android:locale=" en">

Following these steps, you can implement localization in your Android

application and provide a localized experience for users who speak
different languages in different cultures and regions.

related:

create your winning Android developer cover letter (with

samples)read more
10. What is the purpose of
the LayoutInflater in
Android, and how is it used?
The LayoutInflater in Android creates a view hierarchy from an XML layout
file. It instantiates XML layout resources and returns the resulting view
hierarchy. LayoutInflater aims to help developers build user interfaces by
loading XML layout resources and constructing the corresponding view
objects.

To use the LayoutInflater in an Android application, follow these steps:

1. Get a reference to the LayoutInflater by calling the LayoutInflater.from()

method and passing in a context object.
LayoutInflater inflater = LayoutInflater.from(context);

2. Inflate the XML layout file by calling the inflate() method on the
LayoutInflater object. The inflate() method takes two arguments: the
resource ID of the XML layout file and the parent ViewGroup.
View view = inflater.inflate(R.layout.my_layout, parentViewGroup, false);

The first argument is the XML layout file resource ID you want to inflate.
The second argument is the parent ViewGroup to which the inflated view
should be attached. The third argument is a boolean value indicating
whether the inflated view should be immediately attached to the parent
ViewGroup.

3. Use the inflated view as needed in your application. You can access and
manipulate the inflated view's child views by calling findViewById() on the
inflated view object.
TextView textView = view.findViewById(R.id.my_text_view);
textView.setText("Hello, world!");

Using the LayoutInflater in your Android application, you can easily create
and manage complex user interfaces using XML layout resources. The
LayoutInflater provides a simple and efficient way to inflate and manipulate
view hierarchies, making it an essential part of Android app development.

related:

25 essential Android developer interview questions with

answersread more

11. What is the difference

between a service and a
broadcast receiver in
Android?
A service and a broadcast receiver are components in the Android
operating system that perform background tasks but differ in their
functions and how they are used.

A service in the Android system runs in the background and performs long-
running operations, such as downloading files, playing music, or performing
network requests. A service can run indefinitely or be started and stopped
on demand. Services can be started in two ways: started services and bound
services. A started service runs in the background until it completes its task
or is stopped, while a bound service runs only as long as a client is bound
to it.

On the other hand, a broadcast receiver is a component in the Android

system that listens for system-wide broadcast events, such as the battery
level changing, a phone call being received, or a new SMS message being
received. When an event occurs, the broadcast receiver is notified and can
perform some action in response, such as displaying a notification or
starting a service.

In summary, the main difference between a service and a broadcast receiver

is that a service is used to perform long-running background tasks. In
contrast, a broadcast receiver listens to system-wide broadcast events and
performs actions in response to them. Services can be started and stopped
on demand, while broadcast receivers always listen to events.

12. How do you handle

background tasks in an
Android application?
There are several ways to handle background tasks in an Android
application, depending on the nature of the task and the requirements of
the application. Here are some commonly used methods:
• Service: A service is a component in the Android system that runs in
the background and performs long-running operations, such as
playing music, downloading large files, or performing network
requests. A service can run indefinitely or be started and stopped on
demand.

• IntentService: An IntentService is a type of service that can handle

multiple requests on a separate worker thread in a queue. It is
suitable for handling long-running tasks in the background, such as
downloading large files, and it automatically stops itself when the
task is completed.

• JobScheduler: The JobScheduler is a system service introduced in

Android 5.0 Lollipop that allows you to schedule background tasks to
run at specific times or conditions, such as when the device is idle or
 connected to a charger. It is suitable for performing periodic or
recurring tasks, such as syncing data or sending notifications.

• WorkManager: The WorkManager is a library introduced in Android

Jetpack that provides a simple and flexible way to schedule and
manage background tasks in your app. It automatically chooses the
best implementation based on the device's API level, battery level,
and network status.

In general, when handling background tasks in an Android application, it is

important to consider factors such as the nature of the task, the frequency
of execution, and the impact on the device's performance and battery life. It
is also important to choose the appropriate method for handling the task
based on its requirements and the capabilities of the device.

13. What is Android Debug

Bridge(ADB)?
Android Debug Bridge (ADB) is a versatile command-line tool that allows
communication between a computer and an Android device or emulator.
ADB is a part of the Android SDK platform tools and provides a wide range
of functionalities for debugging, installing, and managing Android
applications.

Here are some key features and uses of ADB:

• Debugging: ADB enables developers to debug their Android
applications directly on the device or emulator. It allows for
monitoring log messages, setting breakpoints, and inspecting
variables during debugging.

• Application installation: ADB allows the installation of Android

applications (.apk files) onto a device or emulator. This is particularly
useful during development and testing, as it provides a convenient
way to deploy and update applications.
 • File transfer: ADB allows for transferring files between a computer
and an Android device. This can be helpful when copying files for
testing purposes, accessing device logs, or retrieving application-
specific data.

• Shell access: ADB provides a shell interface that allows developers to

interact with an Android device's command-line shell. This can be
used for executing shell commands, running scripts, and exploring
the device's file system.

• Screen capture: ADB offers the ability to capture screenshots from an

Android device or emulator, which is useful for documentation, app
demonstrations, or bug reporting.

• Performance profiling: ADB provides tools for profiling the

performance of Android applications, including CPU usage, memory
allocation, and network traffic analysis.

To use ADB, you must have the Android SDK installed on your computer
and the device connected through USB debugging enabled. ADB
commands can be executed through your computer's command prompt or
terminal.

Overall, ADB is a powerful tool for Android developers, offering a wide

range of capabilities to aid in debugging, application management, file
transfer, and performance analysis.

14. What are DDMS and

AIDL?
DDMS stands for Dalvik Debug Monitor Server. It is a tool provided by the
Android SDK that allows developers to monitor and debug Android
applications running on emulators or connected devices.
DDMS provides a graphical interface that enables various debugging
features, such as monitoring device and emulator status, examining process
and thread information, inspecting logcat messages, taking screenshots,
and profiling performance.

AIDL stands for Android Interface Definition Language. It is a language

used in Android to define the interface for inter-process communication
(IPC) between different components of an application or between different
applications.

AIDL allows developers to define methods that can be remotely called by

other components or applications, enabling communication and sharing of
data across process boundaries. It is commonly used in scenarios where
components need to communicate across different application boundaries,
such as when using services or implementing client-server architectures in
Android.

In summary, DDMS is a debugging tool used to monitor and debug

Android applications, while AIDL is a language used to define interfaces for
inter-process communication in Android. Both play important roles in the
development and debugging of Android applications.