Android Activity and Lifecycle

What is an Android Activity?

An Activity in Android is a crucial component of an application that provides a user interface

(UI). It represents a single screen with which users can interact. Every Android app contains
one or more activities, and each activity operates independently. Activities are managed by
the Android system in a back stack, ensuring smooth navigation between different screens.

Android Activity Lifecycle

Android activities go through different states from the time they are created to when they
are destroyed. The system calls predefined lifecycle methods to manage these state
changes. The lifecycle of an activity is divided into several stages:

Lifecycle Methods:

1. onCreate(Bundle savedInstanceState)

Called when the activity is first created.

Used to initialize UI elements, set up event listeners, and restore previous states
if available.

2. onStart()

o Called when the activity becomes visible but is not yet interactive.

o Used for UI preparations.

3. onResume()

o Called when the activity is in the foreground and the user can interact with it.

o Used for starting animations, receiving inputs, and handling UI changes.

4. onPause()

o Called when the activity is partially visible (e.g., when a new activity appears
on top).

o Used to pause animations, stop heavy processing, or release resources to

improve performance.

5. onStop()

o Called when the activity is no longer visible (e.g., user navigates away).

o Used to save data and stop unnecessary processes like database access.

6. onDestroy()
 o Called before the activity is completely removed from memory.

o Used to release resources like threads and network connections.

7. onRestart()

o Called when the activity is being restarted after being stopped.

o Used to restore UI states or refresh data.

Activity Lifecycle Diagram:

+--------------------+

| onCreate() | → (Activity is created)

+--------------------+

+--------------------+

| onStart() | → (Activity is visible but not yet interactive)

+--------------------+

+--------------------+

| onResume() | → (Activity is in the foreground and interactive)

+--------------------+

+--------------------+

| onPause() | → (Another activity comes to the foreground)

+--------------------+

+--------------------+

| onStop() | → (Activity is completely hidden)

+--------------------+

+--------------------+
| onDestroy() | → (Activity is removed from memory)

+--------------------+

 If the activity is reopened after stopping, onRestart() is called before onStart().

RecyclerView and Its Implementation Steps

What is RecyclerView?

RecyclerView is an advanced version of ListView used in Android to display large sets of data
efficiently. It improves performance by reusing views, reducing memory usage, and
supporting different layouts like linear, grid, and staggered layouts.

Steps to Implement RecyclerView in Android

Step 1: Add RecyclerView Dependency

To use RecyclerView, you need to add its dependency in the Gradle file of your project. This
allows Android Studio to access the necessary libraries required for RecyclerView.

Step 2: Add RecyclerView to the Layout

You need to add a RecyclerView widget in the XML layout file where you want to display the
list of items. It acts as a container to display the items dynamically.

Step 3: Create a Model Class

A model class is required to represent the data that will be displayed in RecyclerView. This
class usually contains attributes such as text, images, or other data fields relevant to each
item in the list.

Step 4: Create a Layout for List Items

Each item displayed in the RecyclerView needs a separate XML layout file. This file defines
the structure of how each item will appear, such as having a TextView for titles or an
ImageView for pictures.

Step 5: Create an Adapter Class

The adapter is responsible for binding the data to the views in RecyclerView. It handles how
the data should be displayed, recycles views for better performance, and manages user
interactions. The adapter consists of:

 A ViewHolder class that holds the views.

 Methods to create, bind, and count the items.

Step 6: Set Up RecyclerView in Activity or Fragment

In the main activity or fragment, RecyclerView needs to be initialized. You also need to:

 Set a LayoutManager (Linear, Grid, or Staggered).

 Create a list of data that will be displayed.

 Set up the adapter and attach it to RecyclerView.

Step 7: Run the Application

Once all the steps are completed, running the application will display a scrollable list of
items. If configured correctly, RecyclerView will efficiently handle large datasets with
smooth scrolling.

Additional Features of RecyclerView

 Grid Layout: Display items in a grid format instead of a list.

 Click Listeners: Handle user interactions like clicking on items.

 Animations: Add smooth transition effects when items are added or removed.

 Pagination: Load more data when the user scrolls to the bottom.

Intents and Types of Intents in Android

What is an Intent?

An Intent in Android is a messaging object used to request an action from another

component of the app or even another app. It is primarily used for navigating between
activities, services, and broadcasting messages.

For example, an intent can be used to open a new activity, share data, make a call, or open
a web page.

Types of Intents

There are two main types of intents in Android:

1. Explicit Intent

 Used to launch a specific component (such as an activity or service) within the same
application.

 The developer specifies the exact class that should be opened.

 Example use cases:

o Navigating from one activity to another.

o Starting a background service.

2. Implicit Intent

 Used when the destination component is not specified directly. Instead, the system
decides which app or component can handle the request.

 Typically used to interact with other applications.

 Example use cases:

o Opening a web page in a browser.

o Sharing text or images via social media.

o Dialing a phone number.

Other Types of Intents (Based on Usage)

3. Broadcast Intent

 Used to send messages across different components of the system.

 Apps can register Broadcast Receivers to listen for these intents.

 Example use cases:

o Battery low notification.

 o Airplane mode change alert.

4. Pending Intent

 A special type of intent that allows another app or system service to execute an
action on behalf of your app.

 Used in notifications, alarms, and widgets.

 Example use cases:

o Displaying a notification that opens an activity when clicked.

o Setting an alarm to trigger at a later time.

AsyncTask and Connecting a Mobile Application to the Internet

1. AsyncTask in Android

What is AsyncTask?

AsyncTask was a background processing mechanism in Android used for performing short-
duration tasks like downloading data or accessing a database without freezing the UI.
However, AsyncTask is now deprecated (from Android 11) and replaced by alternatives like
Executors, Handlers, or Kotlin Coroutines.

Features of AsyncTask:

 Runs operations in the background.

 Prevents the UI from freezing during long tasks.

 Can update the UI after completion.

Lifecycle of AsyncTask:

1. onPreExecute() – Prepares the task before execution.

2. doInBackground() – Runs the task in a background thread.

3. onProgressUpdate() – Updates the UI while the task is running.

4. onPostExecute() – Executes after the background task is completed, updating the UI.

Why is AsyncTask Deprecated?

 It could cause memory leaks if not handled properly.

  Not efficient for long-running background tasks.

 Alternatives:

o Executors and ThreadPool (Java)

o WorkManager (For persistent background tasks)

o Kotlin Coroutines (Modern and efficient approach)

2. Connecting a Mobile Application to the Internet

Steps to Connect an Android App to the Internet:

Step 1: Add Internet Permission

To access the internet, you must declare the permission in the AndroidManifest.xml file.

Step 2: Choose a Network Library

Android does not allow network operations on the main thread, so a separate thread or
library is required. Some popular options:

 Volley: Easy-to-use library for making API calls.

 Retrofit: Best for handling RESTful APIs.

 OkHttp: Low-level HTTP client for advanced networking.

Step 3: Fetch Data from the Internet

You can fetch data from a server using APIs (Application Programming Interfaces), such as
fetching weather data or user profiles from an online database.

Step 4: Parse and Display Data

The received data (usually in JSON format) needs to be parsed and displayed in the UI using
RecyclerView or other views.

Step 5: Handle Network Errors

Since network connections are unreliable, the app should handle:

 No internet connection

 Slow network speed

 Server errors

History of Mobile Application Development

Introduction
Mobile application development has evolved significantly over the years, from simple pre-
installed apps on early mobile phones to the advanced, AI-driven apps we use today. The
journey of mobile app development can be divided into several key phases.

1. Early Mobile Applications (Pre-2000s)

 In the early days of mobile technology, phones had pre-installed applications such as
calculators, calendars, and simple games (like Snake on Nokia phones).

 These apps were basic, operated on low-processing power devices, and could not be
modified or downloaded.

2. Feature Phone Era (2000–2007)

 Java 2 Micro Edition (J2ME) became a popular platform for mobile apps, enabling
third-party applications to be installed on feature phones.

 Symbian OS (used in Nokia devices) and BlackBerry OS introduced advanced

applications like email clients, messaging apps, and games.

 WAP (Wireless Application Protocol) was used for basic mobile internet access, but it
was slow and limited.

3. Rise of Smartphones (2007–2010)

 2007: Apple launched the first iPhone, introducing iOS and the concept of a modern
touchscreen interface.

 2008: Apple App Store was introduced, allowing users to download and install apps
from a centralized marketplace.

 2008: Google launched Android OS, leading to the creation of the Google Play Store
(formerly Android Market).

 Developers started creating native applications for iOS and Android using Objective-
C (iOS) and Java (Android).

4. Expansion of App Ecosystem (2010–2015)

 Rise of cross-platform development: Developers started using frameworks like

PhoneGap and Xamarin to build apps for both iOS and Android.
  Cloud-based apps emerged, allowing data synchronization across multiple devices.

 Mobile gaming became a billion-dollar industry, with games like Angry Birds and
Candy Crush gaining massive popularity.

 Introduction of mobile payments (Apple Pay, Google Wallet) and social media apps
(Instagram, Snapchat).

5. Modern Mobile App Development (2015–Present)

 Introduction of AI & Machine Learning: Apps like Google Assistant and Siri became
more advanced.

 Rise of Flutter and React Native: Developers can now build cross-platform apps
efficiently.

 5G and Progressive Web Apps (PWAs): Faster networks allow web-based apps to
function like native apps.

 Internet of Things (IoT) apps: Apps now connect to smart home devices, wearables,
and cars.

History of Android

Introduction

Android is the world’s most popular mobile operating system, powering billions of devices.
Developed by Android Inc. and later acquired by Google, Android has evolved from a simple
mobile OS to a powerful platform supporting smartphones, tablets, smart TVs, wearables,
and IoT devices.

1. The Beginning: Android Inc. (2003–2005)

 Founded in 2003 by Andy Rubin, Rich Miner, Nick Sears, and Chris White to develop
a smart operating system for cameras.

 Later, they shifted their focus to mobile phones to compete with Symbian and
Windows Mobile.

 2005: Google acquired Android Inc. for $50 million, and Android became a Google
project.

2. First Android Release (2007–2008)

  2007: Google, along with 34 companies (Samsung, HTC, Qualcomm, etc.), formed the
Open Handset Alliance (OHA) to develop an open-source mobile OS.

 2008: The first Android phone, HTC Dream (T-Mobile G1), was launched with
Android 1.0. It featured:

o Google Search, Gmail, YouTube, Google Maps

o Android Market (later renamed Google Play Store)

3. Android’s Rapid Evolution (2009–2013)

 2009: Android 1.5 Cupcake introduced the on-screen keyboard.

 2009: Android 1.6 Donut added CDMA support, allowing Android phones on more
networks.

 2010: Android 2.2 Froyo introduced hotspot tethering and Flash support in
browsers.

 2011: Android 3.0 Honeycomb was made for tablets, first seen on the Motorola
Xoom.

 2013: Android 4.4 KitKat optimized performance for low-end devices.

4. Android Becomes a Global Leader (2014–2019)

 2014: Android 5.0 Lollipop introduced Material Design UI, a new look for Android.

 2015: Android 6.0 Marshmallow brought app permissions and Google Now on Tap.

 2016: Android 7.0 Nougat introduced split-screen multitasking.

 2017: Android 8.0 Oreo improved battery life with Doze mode.

 2018: Android 9.0 Pie introduced gesture navigation and adaptive battery.

5. Modern Android (2020–Present)

 2019: Android 10 removed dessert names and introduced dark mode and full
gesture navigation.

 2020: Android 11 focused on privacy features and chat bubbles.

  2021: Android 12 brought Material You, a new customizable UI.

 2022: Android 13 improved security, per-app language settings, and better tablet
support.

 2023: Android 14 introduced battery optimizations, AI integrations, and better

foldable phone support.

Brief History of Mobile Applications & Types of Mobile Applications

History of Mobile Applications

1. Early Days (Pre-2000s)

 o Mobile phones had pre-installed apps like calculators, calendars, and simple
games (e.g., Snake on Nokia).

2. Feature Phone Era (2000–2007)

o Java-based J2ME apps enabled third-party app installations.

o BlackBerry OS and Symbian OS introduced email and messaging apps.

3. Smartphone Revolution (2007–2010)

o 2007: Apple launched the first iPhone with a touchscreen interface.

o 2008: Apple App Store and Android Market (now Google Play Store) were
introduced.

4. Modern App Ecosystem (2010–Present)

o Rise of cross-platform development (React Native, Flutter).

o AI-driven apps, cloud computing, and 5G connectivity have improved mobile

experiences.

Types of Mobile Applications

1. Native Apps

 Built for a specific platform (Android or iOS).

 Developed using platform-specific languages (Java/Kotlin for Android,

Swift/Objective-C for iOS).

 Examples: WhatsApp, Instagram, Google Maps.

2. Web Apps

 Mobile-friendly websites accessed via a browser.

 Require an internet connection and are built using HTML, CSS, and JavaScript.

 Examples: Facebook Lite, Twitter Web.

3. Hybrid Apps

 Combine features of native and web apps.

 Developed using frameworks like React Native, Flutter, or Ionic.

  Examples: Uber, Instagram, Gmail.

4. Progressive Web Apps (PWAs)

 Work like web apps but offer offline capabilities and push notifications.

 Can be installed on the home screen without an app store.

 Examples: Twitter PWA, Starbucks App.

Brief History of Android & Features of Android

Brief History of Android

1. Founding & Google Acquisition (2003–2005)

o Android Inc. was founded in 2003 by Andy Rubin to develop an advanced

mobile OS.

o 2005: Google acquired Android and started developing it as an open-source

project.

2. First Android Release (2007–2008)

o 2007: Google launched Android OS and the Open Handset Alliance (OHA).

o 2008: First Android phone, HTC Dream (T-Mobile G1), was released.

3. Growth & Evolution (2009–2019)

o 2009–2013: Introduction of Android versions like Cupcake, Donut,

Gingerbread, and Jelly Bean, bringing touchscreens, app stores, and
improved UI.

o 2014–2019: Material Design UI, better security, and AI integration (Google

Assistant).

4. Modern Android (2020–Present)

o Android 10 (2019) introduced gesture navigation and system-wide dark

mode.

o Android 12 (2021) launched Material You, a fully customizable UI.

o Android 14 (2023) improved battery efficiency, AI-powered features, and

foldable phone support.

Key Features of Android

1. Open-Source

 Android is based on the Linux kernel and is open-source, allowing developers to

modify it.

2. Customizable UI

 Material You (Android 12) introduced dynamic themes based on wallpaper colors.

3. Multi-Tasking

 Supports split-screen mode, picture-in-picture (PIP), and background processing.

4. Google Play Store

 Largest app marketplace with millions of apps available for download.

5. Voice Assistant & AI Integration

 Google Assistant provides voice-based navigation, automation, and AI-powered

features.

6. Security & Privacy

 Features like App Permissions, Play Protect, Encrypted Data Storage, and Biometric
Authentication.

7. Connectivity & IoT Support

 Supports Wi-Fi, Bluetooth, 5G, NFC, and IoT device connectivity.

Anatomy of Android Applications & Setting Up a Real Android Device

Anatomy of an Android Application

An Android application consists of several components that work together to provide

functionality. The key elements of an Android app include:
1. Application Components

 Activities: Represent a single screen with a user interface (e.g., Login Screen, Home
Screen).

 Services: Run in the background to perform long-running operations (e.g., music

player, downloading files).

 Broadcast Receivers: Handle system-wide events like battery low, network change, or
incoming SMS.

 Content Providers: Manage access to shared app data (e.g., contacts, media files,
databases).

2. Android Manifest File (AndroidManifest.xml)

 Declares permissions, app components, hardware features, and themes.

 Example: Requests internet access, camera, location.

3. Resource Files (res/ folder)

 Layouts (layout/): XML files defining UI elements.

 Drawables (drawable/): Stores images, icons, and vector graphics.

 Values (values/): Stores strings, colors, and dimensions.

4. Java/Kotlin Code (src/ folder)

 Contains the app’s logic, written in Java or Kotlin.

 Defines how the app responds to user interactions.

5. Gradle Build System (build.gradle)

 Manages dependencies, SDK versions, and build configurations.

How to Set Up a Real Android Device for Development

1. Enable Developer Options & USB Debugging

1. Open Settings on the Android device.

2. Go to About Phone and tap Build Number 7 times to enable Developer Options.

3. Go back to Settings → Developer Options and enable USB Debugging.

2. Install Necessary Drivers (Windows Users Only)

 Download and install OEM USB drivers from the manufacturer’s website (for
Samsung, Xiaomi, etc.).
3. Connect the Device to the Computer

 Use a USB cable to connect the phone to the PC.

 Choose File Transfer (MTP) mode if prompted.

4. Verify Device Connection in Android Studio

1. Open Android Studio and create/open a project.

2. Click Run (▶) → Select Deployment Target.

3. The connected Android device should appear. If not, type the following command in
Command Prompt/Terminal:

4. adb devices

5. If the device appears, the setup is complete, and you can run your app on the real
device.

Android Terminologies

1. Activity

An Activity represents a single screen in an Android app. It manages the UI and user
interactions. Example: A login screen or a home screen.

2. Intent

An Intent is a messaging object used to communicate between different components

(activities, services, etc.). It can be explicit (specific component) or implicit (system chooses
the component).

3. Service

A Service is a background process that runs without a UI, such as playing music, fetching
notifications, or syncing data.

4. Broadcast Receiver

A Broadcast Receiver listens for system-wide or app-specific events, like battery low,
network change, or SMS received.

5. Content Provider

A Content Provider manages access to structured data (like contacts, media files, or
databases) and allows apps to share data securely.
6. Fragment

A Fragment is a modular UI component that can be used inside an activity. It allows for
flexible UI design, especially in tablets.

7. View & ViewGroup

 View: A UI element like Button, TextView, EditText.

 ViewGroup: A container that holds multiple views, like LinearLayout, RelativeLayout.

8. RecyclerView

A RecyclerView is an advanced UI component used to display lists or grids efficiently by

reusing views (better than ListView).

9. Gradle

Gradle is the build system for Android projects. It manages dependencies, compiles code,
and builds APKs.

10. Manifest File (AndroidManifest.xml)

This file contains app permissions, activity declarations, services, and broadcast receivers.

11. APK (Android Package Kit)

An APK is the installation file of an Android app, similar to .exe in Windows.

12. ADB (Android Debug Bridge)

ADB is a command-line tool used to communicate with Android devices for debugging,
installing APKs, and accessing the shell.

13. ANR (Application Not Responding)

ANR occurs when an app freezes for too long (more than 5 seconds) due to long-running
tasks on the main thread.

14. Dalvik & ART (Android Runtime)

 Dalvik was the original Android runtime (replaced in Android 5.0).

 ART (Android Runtime) improves app performance and battery efficiency.

15. Material Design

Google’s UI design language that ensures a consistent and modern look across Android
apps.
Android Components

Android applications are built using four main components, each serving a specific purpose
in the app’s functionality.

1. Activities

 An Activity represents a single screen in an Android app.

 It handles the UI and user interactions (e.g., login screen, home screen).

 The lifecycle of an activity is managed by Android (e.g., onCreate(), onStart(),

onDestroy()).

Example: A shopping app’s HomeActivity displays product listings.

2. Services

 A Service is a background component that runs without a user interface.

 It is used for long-running tasks such as playing music, fetching notifications, or

syncing data.

 Can be started (startService()) or bound (bindService()).

Example: A music player app runs a background service to play songs even when the app is
closed.

3. Broadcast Receivers

 A Broadcast Receiver listens for system-wide or app-specific events and triggers an

action.

 Events can be battery low, network change, SMS received, boot completed, etc.

 Used to notify the app about external changes.

Example: A messaging app receives an incoming SMS notification using a Broadcast

Receiver.

4. Content Providers

 A Content Provider manages shared app data and allows other apps to access it
securely.
  Used for sharing structured data like contacts, media files, and databases.

 Uses URIs (Uniform Resource Identifiers) to query or modify data.

Example: The Contacts app provides access to phone numbers that can be used by
WhatsApp or Telegram.

Additional Components

5. Fragments

 A Fragment is a reusable UI component inside an Activity.

 Used to create dynamic and flexible UI layouts, especially on tablets.

6. Intent

 Intent is used for communication between different app components (e.g., launching
an activity or a service).

 Explicit Intent: Specifies the target component directly.

 Implicit Intent: The system chooses the appropriate component based on intent
action.

Intent and Its Types in Android

What is an Intent?

An Intent in Android is a messaging object used to request an action from another

component of the application or even a different application. It allows communication
between various components such as Activities, Services, Broadcast Receivers, etc.

For example, you can use an intent to:

 Launch a new activity

  Start a service

 Send a broadcast

 Open a web page, camera, or dialer

Types of Intents

✅ 1. Explicit Intent

 An Explicit Intent clearly specifies the target component by class name.

 It is mainly used within the same application to start a specific activity or service.

Use Case Examples:

 Navigating from LoginActivity to HomeActivity

 Starting a background music service

Characteristics:

 Requires full knowledge of the target component’s class.

 Safe and controlled communication within the app.

✅ 2. Implicit Intent

 An Implicit Intent does not specify the target component.

 Instead, it declares a general action to perform, and the system decides which
component (from your app or other apps) can handle it.

Use Case Examples:

 Opening a webpage in a browser

 Sharing text or image via social media

 Opening the camera app

Characteristics:

 Useful for integrating with other apps or system features

 Requires intent filters to be declared in the manifest for the receiving app
Android Activity and Its Lifecycle (with Callback Methods & Diagram)

🟢 What is an Android Activity?

An Activity in Android represents a single screen with a user interface. It acts as an entry
point for user interaction in an app. For example, the Login page, Home screen, or Settings
screen in an app are all activities.

🔁 Activity Lifecycle Overview

The Android system manages the lifecycle of each activity using a series of callback
methods. These methods help handle transitions between different states like creation,
running, paused, stopped, and destroyed.

📋 Important Callback Methods

Lifecycle Method Purpose

onCreate() Called when the activity is first created. Initialize UI, data, etc.

onStart() Called just before the activity becomes visible to the user.

onResume() Called when the activity starts interacting with the user.

Called when the activity is partially visible or another activity comes in

onPause()
front.

onStop() Called when the activity is no longer visible.

Called when the activity is coming back to the foreground after being
onRestart()
stopped.

onDestroy() Called when the activity is destroyed and removed from memory.

🧭 Diagram of Activity Lifecycle

+-------------------+

| onCreate() |

+-------------------+

+-------------------+

| onStart() |
 +-------------------+

+-------------------+

| onResume() |

+-------------------+

User navigates away (partially or fully)

+-------------------+

| onPause() |

+-------------------+

+-------------------+

| onStop() |

+-------------------+

+-------------------+

| onDestroy() |

+-------------------+

↑ ↓

+------------+ +----------------+

| onRestart()| ←---| Back to app/UI |

+------------+ +----------------+

📝 Summary

 onCreate() to onResume() is when the activity starts.

 onPause() to onStop() is when the activity goes into the background.

 onRestart() is called when an activity is resumed after being stopped.

  onDestroy() is called when the activity is closed or killed.

Android OS and Its Architecture

📱 What is Android OS?

Android is an open-source mobile operating system developed by Google, primarily

designed for smartphones and tablets. It is based on the Linux kernel and allows developers
to build apps in Java or Kotlin using the Android SDK.

🧱 Android Architecture (Layered Structure)

Android OS follows a layered architecture consisting of five main components:

🔹 1. Linux Kernel (Bottom Layer)

 Acts as the core of the Android OS.

 Handles low-level system operations like memory management, device drivers,

power management, and process control.

 Provides abstraction between hardware and software layers.

📌 Example: Communicating with camera, Bluetooth, or Wi-Fi.

🔹 2. Hardware Abstraction Layer (HAL)

 A bridge between the hardware and higher-level Android runtime and framework.

 Provides standard interfaces to communicate with device hardware without knowing

its implementation.

📌 Example: Sensors, audio, graphics, GPS, etc.

🔹 3. Android Runtime (ART) & Core Libraries

 Android Runtime (ART) executes app code and replaces the older Dalvik VM.

 Uses Ahead-of-Time (AOT) compilation to improve performance.

 Core libraries provide Java-like classes (data structures, file access, network, etc.)

📌 Example: Collections, threading, input/output libraries.

🔹 4. Native C/C++ Libraries

 These are pre-built native libraries written in C/C++, which provide support for media
playback, database handling, graphics rendering, etc.

📌 Popular Libraries:

 SQLite (for databases)

 OpenGL ES (for 3D graphics)

 WebKit (for web browsing)

🔹 5. Application Framework

 Provides APIs that developers use to build apps.

 Manages the user interface, application resources, and lifecycle.

📌 Important Components:

 Activity Manager

 Window Manager

 Content Providers

 Package Manager

🔹 6. Applications (Top Layer)

 This is where user-installed apps and built-in apps (like Dialer, SMS, Camera) exist.

 Built using Java/Kotlin + XML UI and use the framework APIs underneath.

Visual Overview (Architecture Layers)

+--------------------------+

| Applications |

+--------------------------+

| Application Framework |

+--------------------------+
 | Android Runtime (ART) |

| + Native Libraries |

+--------------------------+

| Hardware Abstraction |

+--------------------------+

| Linux Kernel |

+--------------------------+

Fragments and Their Lifecycle in Android

📱 What is a Fragment?

A Fragment in Android is a modular section of an activity. It represents a portion of the UI

within an activity and allows for more flexible UI design, especially on devices with larger
screens like tablets.

👉 Think of a fragment as a mini-activity that has its own lifecycle and layout but lives inside
an activity.

✅ Why Use Fragments?

 Reusable UI components

 Better support for multi-pane layouts (like side-by-side views)

 Dynamic UI changes at runtime

 Helps in separating functionality across different parts of the screen

🔁 Fragment Lifecycle

Just like an activity, a fragment has its own lifecycle, which is closely tied to the activity’s
lifecycle. Here's a breakdown of important lifecycle methods:

🔹 1. onAttach(Context context)

 Called when the fragment is first attached to its host activity.

 Useful to get a reference to the activity.

🔹 2. onCreate(Bundle savedInstanceState)

 Called to initialize fragment data.

 Does not create the UI here.

🔹 3. onCreateView(LayoutInflater inflater, ViewGroup container, Bundle

savedInstanceState)

 Called to inflate the layout (UI) of the fragment.

 This is where you return the view for your fragment UI.

🔹 4. onViewCreated(View view, Bundle savedInstanceState)

 Called after the fragment's view has been created.

 Useful to initialize view components like buttons, text, etc.

🔹 5. onStart()

 Called when the fragment becomes visible to the user.

🔹 6. onResume()

 Fragment is actively running and interacting with the user.

🔹 7. onPause()

 Fragment is no longer in the foreground, but still visible.

 Used to pause animations or heavy tasks.

🔹 8. onStop()

 Fragment is no longer visible.

 Free up resources that are not needed when hidden.

🔹 9. onDestroyView()

 View hierarchy of the fragment is removed.

 Use this to clean up UI resources.

🔹 10. onDestroy()

 Called to do final cleanup of fragment’s data.

🔹 11. onDetach()

 Called when the fragment is disconnected from its host activity.

Fragment Lifecycle Diagram

onAttach()

onCreate()

onCreateView()

onViewCreated()

onStart()

onResume()

onPause()

onStop()

onDestroyView()
 ↑

onDestroy()

onDetach()

How to Handle Click Event on a Button in Android

In Android, handling a button click means responding to the user's action when they tap on
a button in your app's user interface. This is one of the most common and important
interactions in any app.

Steps to Handle Button Click (Without Code)

✅ 1. Add a Button to the Layout

 In your layout XML file, add a Button with a unique ID.

 This makes the button visible on the screen and identifiable in your code.

✅ 2. Access the Button in Your Activity

 In your Java or Kotlin activity, you reference the button using its ID so you can
interact with it in code.

✅ 3. Set an OnClickListener

 You attach a listener to the button to monitor when it is clicked.

 When the button is clicked, the listener triggers a function or action (like showing a
message, opening a new screen, or performing calculations).
📋 Ways to Handle Click Events

🔹 1. Using setOnClickListener

 Attach a click listener directly in the code.

 Best when you want dynamic control in Java/Kotlin.

🔹 2. Using android:onClick in XML

 Declare the function name in XML and define that function in your activity.

 Simpler and good for quick apps with fewer buttons.

💡 Common Actions on Click

 Navigating to another activity

 Showing a toast or dialog

 Fetching data

 Starting a background task

 Playing sound or animation

Views and ViewGroups in Android

In Android, Views and ViewGroups form the building blocks of the user interface (UI). They
work together to create and organize everything the user sees and interacts with on the
screen.

📌 What is a View?

A View is the basic UI element in Android that represents a rectangular area on the screen.
It is used to display content or capture user input.

🧩 Examples of Views:

 TextView – displays text

 EditText – allows user input

 Button – clickable button

 ImageView – displays images

 CheckBox, RadioButton, Switch, etc.

✅ Features:

 Can detect user gestures (click, touch)

 Can display content (text, images)

 Has properties like size, color, position, padding, etc.

📌 What is a ViewGroup?

A ViewGroup is a container that holds one or more Views or other ViewGroups. It defines
how child views are arranged on the screen.

🧩 Examples of ViewGroups:

 LinearLayout – arranges children in a single row or column

 RelativeLayout – arranges children relative to each other

 ConstraintLayout – flexible layout using constraints

 FrameLayout, GridLayout, CoordinatorLayout, etc.

✅ Features:

 Organizes and manages layout of child views

 Handles nesting and hierarchy of UI elements

 Can apply margins, padding, gravity to children

🧱 Relationship Between View and ViewGroup

 ViewGroup is a subclass of View.

 Every ViewGroup is also a View, but not every View is a ViewGroup.

 ViewGroups can contain multiple Views, while Views are leaf nodes (they cannot
contain other views).

📊 Example UI Structure:

<LinearLayout> ← ViewGroup

├── <TextView> ← View

├── <Button> ← View

└── <ImageView> ← View

</LinearLayout>

📝 Summary

Feature View ViewGroup

Purpose Display UI content Arrange and manage child views

Can contain? ❌ No ✅ Yes (other views/viewgroups)

Examples TextView, Button, ImageView LinearLayout, ConstraintLayout

Inheritance Base class Subclass of View

Background Task and AsyncTask in Android (with Limitations)

In Android, background tasks are operations that run in the background thread instead of
the main (UI) thread, to keep the app responsive and smooth for the user.

✅ Background Tasks in Android

These are tasks that:

 Don’t require immediate UI updates.

 Run outside the main thread.

 Are used for operations like:

o Fetching data from the internet

o Downloading/uploading files

o Reading/writing to database

o Heavy computations

🔧 Common Tools for Background Tasks:

 AsyncTask (deprecated now)

 Thread & Handler

 Executors

 WorkManager (recommended for long-running tasks)

  Services (e.g., IntentService)

 Coroutines (in Kotlin)

⚙️What is AsyncTask?

AsyncTask is a helper class in Android that makes it easier to perform background

operations and publish results on the UI thread without having to manage threads and
handlers manually.

It works with three main methods:

1. doInBackground() – runs on background thread.

2. onPreExecute() – runs before background starts (UI thread).

3. onPostExecute() – updates UI after background finishes.

⚠️Limitations of AsyncTask

1. Deprecated in API 30+:

Google has officially deprecated AsyncTask due to its poor lifecycle handling.

2. Tied to Activity Lifecycle:

If the activity is destroyed (e.g., screen rotation), the task may leak memory or cause
crashes.

3. Not Suitable for Long Tasks:

AsyncTask is good for short operations. For long-running tasks, it can be killed by the
system.

4. Single Thread Limitation:

Earlier versions executed tasks serially; only later versions allowed parallel execution
via .executeOnExecutor().

5. Difficult to Cancel Cleanly:

Cancelling a task is not always straightforward and may leave things in an
inconsistent state.

6. No Error Handling:
Doesn’t have built-in support for exceptions or retries.

✅ Modern Alternatives to AsyncTask

 WorkManager – for reliable, deferrable background work.

 Coroutine (Kotlin) – lightweight and lifecycle-aware.

 ExecutorService + Handler – for more control over threads.

 JobIntentService / Services – for operations requiring background service context.