Android Architecture

Android architecture is structured in a layered

format that comprises several components
organized in a hierarchy. These layers enable
the Android operating system to efficiently
manage the device hardware, support
application functionality, and maintain smooth
interactions for the user. Let's explore each
layer in detail to understand the entire Android
ecosystem.

1. Linux Kernel
The Linux Kernel forms the foundational layer
of the Android architecture. It directly interacts
with the device’s hardware, making it the core
part of the OS. Key responsibilities of the Linux
kernel include:
Device Drivers: It contains essential drivers that
communicate with hardware components like
display, camera, Wi-Fi, audio, and Bluetooth.

Power Management: Manages power

consumption, ensuring efficient use of battery
and system resources.

Memory Management: Controls and allocates

memory for different processes and
applications.

Resource Access: Manages access to device

resources, ensuring applications do not
interfere with each other's functions.

By managing these low-level operations, the

Linux Kernel enables Android to operate
smoothly on a variety of devices with different
hardware configurations.

2. Native Libraries

Positioned above the Linux Kernel are Android's

Native Libraries, which provide crucial functions
for various system features. Some important
native libraries include:

WebKit: Powers the web browser and web-

related functionalities.

OpenGL: Handles graphics rendering,

particularly for 3D graphics, making it essential
for gaming and graphical apps.
SQLite: Supports database management within
the application.

FreeType: Provides font support, enhancing text

rendering across applications.

Media Libraries: Used for audio and video

playback, enabling apps to handle multimedia
content.

SSL (Secure Socket Layer): Ensures secure data

transmission over networks.

These libraries offer essential services,

enabling app developers to integrate
functionalities like internet browsing, database
storage, and media playback.
3. Android Runtime

The Android Runtime layer, situated alongside

the Native Libraries, is crucial for running
applications. It comprises two main
components:

Core Libraries: Provide essential functionalities

to the Android application framework, enabling
the smooth operation of apps.

Dalvik Virtual Machine (DVM): Similar to the

Java Virtual Machine (JVM), the Dalvik VM is
optimized for mobile devices. It uses a special
bytecode format and has low memory usage,
which allows Android apps to run efficiently
even on low-powered devices.
Dalvik has since been replaced by Android
Runtime (ART) in newer versions of Android,
which improves performance, particularly in
memory management and execution speed.

4. Application Framework

The Application Framework layer is a significant

part of Android's architecture. It provides APIs
(Application Programming Interfaces) that
developers use to create Android apps. The
Application Framework offers high-level
services in the form of Java classes. These
services include:

Activity Manager: Manages the lifecycle of

applications and maintains an activity stack.
Content Providers: Allow applications to share
data with each other.

Resource Manager: Provides access to non-

code resources, such as strings and user
interface layouts.

Notification Manager: Manages notifications,

allowing applications to send alerts to the user.

View System: Contains UI components (like

buttons, labels, etc.) used to build the user
interface.

The Application Framework enables developers

to use existing services and components, which
speeds up the application development process.
5. Applications

At the top of the Android architecture is the

Application layer, where all Android applications
reside. This layer includes the core applications
that come pre-installed with Android (such as
Contacts, Email, Browser, and Games) and third
-party applications installed by users. Each
application utilizes the Android Framework APIs
to interact with the Android system, enabling
diverse functionalities.

Android Application Components

Applications in Android are built using specific

components, each serving unique functions
within an app. These components include:
Activities: Represent individual screens in an
app where users interact. For example, an email
app might have an activity for viewing emails
and another for composing messages.

Services: Run background operations, like

playing music or fetching data over a network.

Broadcast Receivers: Respond to system-wide

events or broadcasts from other apps, enabling
the app to react to specific events like network
changes or incoming SMS.

Content Providers: Allow data sharing between

applications, making data available to other
apps when needed.
These components provide the building blocks
for developing Android applications, enabling
apps to interact with each other and with the
Android system.

Additional Components

Other vital components that contribute to the

Android ecosystem include:

Intents: Used to communicate between

different components within an app, such as
starting a new activity or service.

Fragments: Modular sections within an activity,

allowing for dynamic and flexible UI designs.
AndroidManifest.xml: A configuration file that
contains essential information about the app,
like its components, permissions, and hardware
requirements.

Views and Layouts: Views are the UI elements

like buttons and text fields, while layouts define
the structure of these views on the screen.

By combining all these layers and components,

Android architecture creates a robust
environment for app development, supporting
millions of diverse applications across various
devices and use cases. This layered
architecture not only enhances Android's
flexibility and scalability but also ensures that
applications run smoothly and interact
effectively with both the system and each other.
The document you provided covers the Android
Activity Lifecycle in detail, describing each
stage's purpose and function. Here’s a
structured and expanded explanation for your
exam preparation, organized as a long-answer
format:

---

Android Activity Lifecycle

An Activity in Android represents a single

screen with a user interface, responsible for
user interactions and handling various states
during its lifecycle. Each activity in an
application follows a defined sequence of
states, with callback methods managed by the
Android system. Understanding each of these
methods is essential for controlling the
behavior and performance of an Android app.
Below is a comprehensive explanation of each
lifecycle stage:

1. onCreate()

Purpose: This is the first method called when

an activity is created. It's used to initialize
essential components like the user interface
(UI), data binding, and any required resources.

Functionality: In onCreate(), you set up the

activity’s layout by calling setContentView() and
perform basic application startup logic. Once
this method finishes, the activity enters the
Started state.
Usage: For example, initializing UI elements,
setting up ViewModels, or configuring external
resources.

2. onStart()

Purpose: Called when the activity becomes

visible to the user, preparing it to enter the
foreground and become interactive.

Functionality: This method is where you

typically load data that needs to be displayed or
update UI elements. The activity becomes fully
visible but is not yet interactive.
Usage: For example, onStart() is commonly
used to set up resources that support the UI,
like starting animations or displaying data
loaded from local storage.

3. onResume()

Purpose: This method is invoked when the

activity enters the foreground and is ready for
the user to interact with.

Functionality: At this stage, the app is active

and responsive to user input, handling UI
interactions such as touch events and button
clicks.

Usage: onResume() is useful for starting tasks

that require user interaction, like video playback
or animations. The app remains in this state
until a change (e.g., a phone call) shifts focus
away from the activity.

4. onPause()

Purpose: Called as the first sign that the user is

leaving the activity. It indicates the app is
partially visible, though not in the foreground.

Functionality: Use onPause() to pause ongoing

tasks, save user progress, or stop activities that
should not run in the background.

Usage: This might include pausing videos,

stopping animations, or saving unsaved data.
onPause() is a crucial method for managing
resources when the activity is not in full view
but may still be partially visible.

5. onStop()

Purpose: This method is called when the

activity is no longer visible on the screen, as
another activity is now in the foreground.

Functionality: In onStop(), you can release

resources that are not needed while the activity
is stopped. This may occur if a new activity
completely covers the screen.

Usage: Free up resources that are heavy on

memory, such as closing database connections
or stopping background threads.

6. onDestroy()

Purpose: Invoked when the activity is about to

be destroyed, either due to user action (like
pressing back) or a configuration change (like
rotating the device).

Functionality: The onDestroy() method is where

you should clean up any remaining resources
that may lead to memory leaks if not released.

Usage: onDestroy() is ideal for releasing

resources that persist throughout the activity’s
lifecycle, like unregistering broadcast receivers
or stopping services.
7. onRestart()

Purpose: Called when the activity is restarted

after having been stopped. This can happen
when the user returns to the activity after
navigating away from it.

Functionality: onRestart() allows you to

reinitialize resources or update data if the
activity is coming back from a stopped state.

Usage: Use this to refresh the UI, reload data, or

reinitialize processes that were paused or
stopped.
Summary

The Android Activity Lifecycle ensures smooth

transitions between these states, allowing apps
to manage resources efficiently and create a
seamless user experience. By understanding
and implementing the correct lifecycle
callbacks, developers can control the visibility,
behavior, and resource management of an
activity at each stage.

Layouts in Android - Long Answer Guide

In Android development, layouts define the user

interface (UI) of an application. These layouts
are frameworks where various UI components,
known as Views and ViewGroups, are organized
to display on an activity screen. An activity in
Android serves as a single, focused task the
user can do, essentially functioning as a "page"
of the app. Views represent elements like text,
images, and buttons, while ViewGroups
organize these elements within the layout.

1. Views and ViewGroups

View: A View is an individual UI element, also

known as a widget, such as TextView,
ImageView, or Button. It handles user
interactions and drawing on the screen.

ViewGroup: This is a container that holds

multiple Views and defines the layout
properties for arranging these Views on the
screen. It acts as a base for layouts like
LinearLayout or RelativeLayout.
2. Types of Layouts in Android

LinearLayout: Aligns its child elements in a

single direction, either vertically or horizontally,
as specified by the android:orientation attribute.

RelativeLayout: Positions each element relative

to others or to the parent, providing a flexible
layout without needing nested structures, which
can improve performance.

ConstraintLayout: A powerful layout that allows

for complex UI designs by specifying
constraints between views, enabling more
responsive layouts. It’s similar to
RelativeLayout but offers more control and is
efficient.

FrameLayout: Primarily used to hold a single

child view, as it stacks additional child views on
top, which can result in overlapping.

TableLayout: Organizes children into rows and

columns, suitable for displaying data in a grid
format without visible gridlines.

AbsoluteLayout: Allows precise positioning of

child elements using X and Y coordinates but is
less flexible and rarely used today.

GridView: Displays items in a grid and

automatically manages content using an
adapter to fit the screen.
ListView: Displays a scrollable, single-column
list of items, populated using an adapter,
making it ideal for lists that need to handle
large datasets efficiently.

3. Attributes Commonly Used in Layouts

Size and Positioning: Attributes like

android:layout_width, android:layout_height,
android:layout_marginLeft, and
android:layout_marginTop control the size and
placement of views.

Alignment: For example, layout_alignParentLeft

aligns a view to the left of its parent, while
layout_centerInParent centers it within the
parent view.
Spacing and Gravity: android:layout_gravity
adjusts a view’s position within its layout
boundaries, and android:weightSum in
LinearLayout distributes space proportionally
among child views.

4. Advantages and Limitations

ConstraintLayout is advantageous due to its

drag-and-drop feature in Android Studio,
efficient grouping of widgets, and support for
animations. However, its XML structure can
become complex, and layouts may vary
between design and runtime.

RelativeLayout offers flexibility with fewer

nested layouts, enhancing performance, though
it can become complex with multiple nested
dependencies.

FrameLayout is suitable for single-view content

but can lead to overlap when holding multiple
views, requiring careful arrangement.

TableLayout and GridView are beneficial for

displaying data but may lack fine control over
the content arrangement when complex
designs are needed.

In summary, each layout in Android serves a

specific purpose and is selected based on the
design needs and structure of the app.
Understanding the characteristics of each
layout type helps developers create efficient
and responsive UIs tailored to their app’s
requirements.

Detailed Explanation of TextView in Android

1. Introduction to TextView

Definition: TextView is one of the fundamental

UI elements in Android, used for displaying text
to users.

Importance: It enhances user experience by

controlling how information appears on the
screen. For example, TextView can highlight
important parts by making them bold or italic,
and it can handle hyperlinks, making specific
texts clickable to redirect to web URLs.
2. Attributes of TextView

Typeface: Controls the font style, offering four

main types:

Serif: Fonts with decorative strokes.

Sans-Serif: Modern-looking fonts without

strokes.

Monospace: Fonts where each letter has the

same width.
Example:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Android Programming"
android:textSize="32sp"
android:typeface="serif" />

Size of TextView: Specifies the size of text

through the textSize attribute. It’s essential for
differentiating headings and body text.

Example:

<TextView
 android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Heading Text"
android:textSize="24sp" />

3. Text Styling Options

Text Style: Android offers three text styles -

Bold, Italic, and Normal.

Example:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
 android:text="Styled Text"
android:textStyle="italic" />

Text Color: Used to change the color of text

based on context, such as using red for
warnings. Colors can be specified using hex
codes or predefined Android colors.

Example:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Warning Text"
android:textColor="#B00020" />
4. Advanced Text Attributes

Text Shadow: Adds shadow to text with three

properties: shadowDx, shadowDy, and
shadowRadius.

Example:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Shadowed Text"
android:shadowDx="4"
android:shadowDy="4"
android:shadowRadius="10"
 android:shadowColor="@color/green_500" />

Adding Icons: Icons can be added to TextView

in four positions – start, end, top, or bottom.

Example:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Text with Icon"
android:drawableStart="@drawable/ic_icon"
/>

5. Hyperlink and AutoLink Functionality

AutoLink: Automatically detects URLs, emails,
and phone numbers, making them clickable
within TextView.

Example:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:autolink="all"
android:text="http://www.google.com" />

Summary
TextView in Android is a versatile tool that
allows for text display customization,
enhancing user interaction through styling,
linking, shadow effects, and more. By
configuring these attributes, developers can
present text in a user-friendly, engaging way.

Android UI Components

In Android development, UI components are

essential elements that help create an
interactive and aesthetically pleasing interface.
These components enable users to engage with
the application effectively. Here’s a detailed
breakdown of the main Android UI components:

1. TextView
TextView is a UI component used to display
text to the user. It functions like a label,
showing text but not allowing users to edit it.

Attributes:

android:id: Unique identifier for the TextView.

android:width and android:height: Define the

size.

android:textColor: Sets the text color.

android:gravity: Aligns the text within the

TextView.
2. EditText

EditText is an editable text field, used to accept

user input, commonly in forms.

It is a subclass of TextView, but allows text

editing.

3. Button

A Button is a push-button UI component that

performs an action when clicked.

Types include CompoundButton (a button that

combines functionality), ToggleButton (shows
ON/OFF state), and RadioButton (a button that
can only be checked or unchecked once).

4. ImageButton

Similar to Button, but displays an image. The

image source must be specified to load the
desired image on the button.
5. ToggleButton

Displays an ON/OFF state, often indicated with

a light or color change.

6. RadioButton

A RadioButton can be either checked or

unchecked. Once checked, it cannot be
unchecked individually (unless in a group where
another button is selected).

7. RadioGroup
A collection of RadioButtons where only one
can be selected at a time, ensuring a single-
choice selection.

8. CheckBox

A CheckBox allows multiple selections in a

group, unlike RadioGroup.

9. ProgressBar
Shows the progress of a task, such as
downloading. It has two modes:

Determinate: Shows completion percentage.

Indeterminate: Runs continuously without

indicating when it will complete.

10. Spinner

Similar to a dropdown list in HTML, the Spinner

lets users select one option from a list.
11. TimePicker

Allows users to select a specific time. It can

display time in 24-hour or 12-hour AM/PM
format.

12. DatePicker

A UI component for selecting a date, typically

shown with a calendar interface.
13. SeekBar

An enhanced ProgressBar with a draggable

pointer, allowing users to set a specific value
within a range.

14. RatingBar

Similar to SeekBar but used for ratings, typically

with star icons where users can rate on a scale
(e.g., 0 to 5 stars).
15. AlertDialog

A dialog box that alerts the user with a

message or warning and prompts a response
(e.g., retry, cancel).

16. Switch

A two-state (ON/OFF) component similar to

ToggleButton, but more visually distinct.

17. AutoCompleteTextView
Extends EditText by providing text suggestions
as users type, helping with inputs that have
common values.

Each of these components enhances user

interaction in an Android application, making
the interface intuitive and efficient.