MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

UNIT - 1
Chapter 3 : Using Activities, Fragments and Intents in Android
 Activity Lifecycle
In Android development, an Activity represents a single screen with a user interface, functioning
as a crucial component of an application. Understanding the Activity Lifecycle is essential for
managing how activities are created, paused, resumed, and destroyed, ensuring optimal
performance and a seamless user experience.

The Activity Lifecycle comprises several states, each corresponding to a specific callback
method:

1. onCreate(): Invoked when the activity is first created. This is where you initialize
essential components, set up the user interface, and perform one-time setup procedures.

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.Layout.activity_main);
}

2. onStart(): Called when the activity becomes visible to the user but is not yet interactive.
At this point, the activity is in the foreground.

@Override
protected void onStart()
{
super.onStart();
}

3. onResume(): Executed when the activity starts interacting with the user. The activity is
now at the top of the activity stack and receives user input.

@Override
protected void onResume()
{
super.onResume();
}

4. onPause(): Triggered when the system is about to resume another activity, indicating that
the current activity is no longer in the foreground. This is where you should save any
unsaved data and release resources that are not needed while the activity is paused.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

@Override
protected void onPause()
{
super.onPause();
}

5. onStop(): Occurs when the activity is no longer visible to the user. This can happen when
a new activity starts, or the current activity is being destroyed. At this stage, the activity
should release resources that are not needed while the activity is not visible.

@Override
protected void onStop()
{
super. onStop();
}

6. onDestroy(): Called before the activity is destroyed. This is the final call that the activity
receives and is used to clean up resources that have not yet been released.

@Override
protected void onDestroy()
{
super. onDestroy();
}

7. onRestart(): Invoked after the activity has been stopped and just before it is started
again. This is typically used to reinitialize components that were released during
onStop().

@Override
protected void onRestart()
{
super. onRestart();
}

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

Visual Representation

 onCreate(): Called when the activity is first created.

 onStart(): Called when the activity becomes visible to the user.
 onResume(): Called when the activity starts interacting with the user.
 onPause(): Called when the system is about to resume another activity.
 onStop(): Called when the activity is no longer visible to the user.
 onDestroy(): Called before the activity is destroyed.

 Features and Functionalities of an Activity

 User Interface Management: An activity is responsible for rendering the user interface,
allowing users to interact with the application. Developers define the layout and behavior of UI
components within an activity.

 Lifecycle Handling: Activities have a well-defined lifecycle, comprising states such as

creation, start, resume, pause, stop, and destruction. Proper management of these states ensures
efficient resource utilization and a smooth user experience.

 Event Handling: Activities process user inputs like clicks, touches, and gestures, enabling the
application to respond to user actions appropriately.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

 Intent Management: Activities can initiate other activities or applications using intents,
facilitating inter-component communication and task delegation. For example, an activity can
send an intent to open a web page in a browser.

 Data Persistence: Activities can save and restore UI state and user data during lifecycle
events, such as configuration changes or when the system reclaims resources, ensuring continuity
in user experience.

 Fragment Management: Activities can host multiple fragments, which are modular
components representing portions of the user interface, allowing for more flexible and dynamic
UI designs.

 Permissions Handling: Activities can request runtime permissions from users to access
protected resources like the camera or location services, ensuring compliance with security
protocols.

 Communication : Activities can communicate with other components such as services,

broadcast receivers, and content provider.

 Applying Styles and Themes to an Activity

In Android development, styles and themes are essential tools that allow developers to define
the visual aesthetics and consistent design elements of an application. They enable the separation
of design details from the core UI structure and behavior, akin to stylesheets in web design.

Styles:

A style is a collection of attributes that specify the appearance and format for a UI element, such
as a View or window. By defining styles, developers can ensure a consistent look and feel across
various UI components. Styles are typically defined in XML resource files, separate from the
layout XML, promoting modularity and reusability.

<TextView

style="@style/CustomTextStyle"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, World!" />

Themes:

A theme is a broader set of styles or attributes that apply to an entire application, activity, or
view hierarchy. Themes define the overall look and feel of an app, including colors, typography,
and shapes, ensuring a cohesive user experience.

<resources>

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

<style name="AppTheme" parent="Theme.MaterialComponents.DayNight.DarkActionBar">

<!-- Primary brand color. -->
<item name="colorPrimary">@color/purple_500</item>
<item name="colorPrimaryVariant">@color/purple_700</item>
<item name="colorOnPrimary">@color/white</item>
<!-- Secondary brand color. -->
<item name="colorSecondary">@color/teal_200</item>
<item name="colorSecondaryVariant">@color/teal_700</item>
<item name="colorOnSecondary">@color/black</item>
<!-- Other attributes -->
</style>
</resources>

Applying this theme in the AndroidManifest.xml ensures that the specified styles are consistently
used throughout the application:

<application
android:theme="@style/AppTheme">
<!-- Activities and other components -->
</application>

Best Practices:

 Consistency: Utilize styles and themes to maintain a uniform design across the
application, enhancing user experience.
 Modularity: Define styles and themes in separate XML files to promote clean code
architecture and ease of maintenance.
 Customization: Leverage themes to allow users to switch between different visual
modes, such as light and dark themes, accommodating user preferences.

 Dialogs in activity

In Android development, a dialog is a small window that prompts the user to make a decision or enter
additional information. Unlike activities, dialogs do not occupy the entire screen and are typically used
for modal events that require users to take an action before proceeding.

Creating an AlertDialog in an Activity:

Below is a Java example demonstrating how to create and display an AlertDialog within an
activity:

import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

// Create the AlertDialog builder

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Sample Dialog");
builder.setMessage("This is an example of an AlertDialog.");

// Set the positive button and its click listener

builder.setPositiveButton("OK", new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dialog, int which) {
// Handle the positive button click
dialog.dismiss();
}
});

// Set the negative button and its click listener

builder.setNegativeButton("Cancel", new
DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// Handle the negative button click
dialog.dismiss();
}
});

// Create and show the AlertDialog

AlertDialog dialog = builder.create();
dialog.show();
}
}

Explanation:

 AlertDialog.Builder: Constructs the dialog, setting its title and message.

 setPositiveButton: Defines the text and behavior for the positive action button.
 setNegativeButton: Defines the text and behavior for the negative action button.
 create(): Builds the AlertDialog instance.
 show(): Displays the dialog to the user.

Types of Dialogs in activity

 Alert Dialog: This dialog displays a title, a message, and up to three buttons. It's commonly
used to present users with information or to prompt them for a decision.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

 DatePicker Dialog: This dialog provides a user interface for selecting a date. It's useful in
scenarios where the user needs to input a specific date, such as setting a reminder or scheduling
an event.

 TimePicker Dialog: Similar to the DatePicker Dialog, this dialog allows users to select a
time. It's often used in applications that require time input, like setting alarms or meeting times.

 Custom Dialog: Developers can create custom dialogs tailored to specific application needs
by defining a custom layout. This allows for flexibility in designing the dialog's appearance and
behavior.

 ButtomSheet Dialog: This dialog slides up from the bottom of the screen. This provides a
modern way to present actions to users.

 ProgressBar in Android

In Android development, a ProgressBar is a user interface element that visually represents the
progress of an ongoing operation, such as downloading a file or loading content. It provides
users with feedback on the status of tasks, enhancing the overall user experience.

Types of ProgressBar in Android:

1. Determinate ProgressBar: Displays a specific quantity of progress. Use this when the
duration of the task is known, allowing the progress to be measured and displayed
accurately. Typically represented as a horizontal bar that fills up as the task progresses.
2. Indeterminate ProgressBar: Indicates that an operation is occurring without specifying
the amount of progress. Use this when the duration of the task is unknown or cannot be
determined. Often displayed as a cyclic animation, such as a spinning wheel.

Example of a Determinate Horizontal ProgressBar:

<ProgressBar
android:id="@+id/progressBar"
style="?android:attr/progressBarStyleHorizontal"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:max="100"
android:progress="50" />

Example of an Indeterminate Circular ProgressBar:

<ProgressBar
android:id="@+id/progressBarIndeterminate"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:indeterminate="true" />

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

 Intent
In Android development, an Intent is a messaging object used to request an action from another
app component, facilitating communication between different components, such as activities,
services, and broadcast receivers.

Navigating Between Activities Using Intents:

To navigate from one activity to another, you can use an explicit intent that specifies the target
activity. Here's how to implement this:
1. Create the Activities:
Intent intent = new Intent(FirstActivity.this,SecondActivity.class);

2. Passing Extra Data Between Activities:

You can pass data to the target activity using the putExtra() method:
intent.putExtra("key", "value");

3. Starting the Activity :

startActivity(intent);

In SecondActivity, retrieve the data:

String value = getIntent().getStringExtra("key");

Example: Switching Between Two Activities

MainActivity.java activity_main.xml
package com.example.intentexample; <?xml version="1.0" encoding="utf-8"?>
import android.content.Intent; <LinearLayout
import android.os.Bundle; xmlns:android="http://schemas.android.com/ap
import android.view.View; k/res/android"
import android.widget.Button; android:layout_width="match_parent"
import androidx.appcompat.app.AppCompatActivity; android:layout_height="match_parent"
android:orientation="vertical"
public class MainActivity extends AppCompatActivity { android:gravity="center">
@Override
protected void onCreate(Bundle savedInstanceState) { <Button
super.onCreate(savedInstanceState); android:id="@+id/button"
setContentView(R.layout.activity_main); android:layout_width="wrap_content"
android:layout_height="wrap_content"
Button button = findViewById(R.id.button); android:text="Go to Second Activity"/>
button.setOnClickListener(new View.OnClickListener() { </LinearLayout>
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this,
SecondActivity.class);

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

intent.putExtra("message", "Hello from

MainActivity!");
startActivity(intent);
}
});
}
}
SecondActivity.java activity_second.xml

package com.example.intentexample; <?xml version="1.0" encoding="utf-8"?>

import android.os.Bundle; <LinearLayout
import android.widget.TextView; xmlns:android="http://schemas.android.com/a
import androidx.appcompat.app.AppCompatActivity; pk/res/android"
android:layout_width="match_parent"
public class SecondActivity extends AppCompatActivity { android:layout_height="match_parent"
@Override android:orientation="vertical"
protected void onCreate(Bundle savedInstanceState) { android:gravity="center">
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second); <TextView
android:id="@+id/textView"
TextView textView = findViewById(R.id.textView); android:layout_width="wrap_content"
String message = getIntent().getStringExtra("message"); android:layout_height="wrap_content"
textView.setText(message); android:text="Welcome to Second
} Activity"/>
} </LinearLayout>

 MainActivity has a button. When clicked, it starts SecondActivity using an Intent and
passes a message.
 SecondActivity retrieves the message using getIntent().getStringExtra("message")
and displays it in a TextView.

Key Features of Intents:

1. Component Interaction: Intents allow seamless interaction between different
components within the same application or across different applications.
2. Action Specification: Intents can define a general action to be performed, such as
ACTION_VIEW to display data to the user or ACTION_SEND to send data from one activity
to another.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

3. Data Transfer: Intents can carry data between components using key-value pairs, known
as "extras." This feature is particularly useful for passing information to the component
being started.
4. Intent Filters: Components can declare intent to specify the types of Intents
5. Broadcasting Messages: Intents can be used to broadcast messages to multiple
components simultaneously. For example, a system event like a low battery warning can
be broadcasted to notify all interested components.
6. Explicit and Implicit Intents: Developers can use explicit intents to target a specific
component within the app or implicit intents trigger action without specifying the target.

Types of Intents
In Android development, Intents are used for communication between components (activities,
services, etc.). There are two main types of intents:

1. Explicit Intent

 Used to start a specific activity or service.

 The developer specifies the target component (e.g., another activity).
 Commonly used for navigation within an app.

Example of Explicit Intent

Intent intent = new Intent(MainActivity.this, SecondActivity.class);
intent.putExtra("contact_id”, contact_id);
startActivity(intent);

🔹 Here, SecondActivity.class is explicitly mentioned.

2. Implicit Intent

 Used when the target component is not specified.

 The system determines the best app to handle the request.
 Commonly used to open web pages, dial numbers, send emails, etc.

Example of Implicit Intent

Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("https://www.google.com"));
if(intent.resolveActivity(getPackageManager())!=null)

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

{
startActivity(intent);
}
1. Important Methods in Intent Class
Method Description

Sets the action for the intent (e.g.,

setAction(String action)
Intent.ACTION_VIEW).

getAction() Returns the action of the intent.

Sets the data (URI) for the intent (e.g.,

setData(Uri uri)
opening a webpage).

getData() Retrieves the data URI.

Specifies the MIME type (e.g.,

setType(String type)
"image/png").

getType() Retrieves the MIME type.

setClass(Context packageContext, Class<?>

cls) Specifies the target activity or service.

setFlags(int flags) Adds flags to control activity behavior.

addFlags(int flags) Adds additional flags to the existing ones.

putExtra(String name, int value) Passes extra data to the intent.

getIntExtra(String name, int defaultValue) Retrieves an integer extra from the intent.

putExtra(String name, String value) Passes a string extra to the intent.

getStringExtra(String name) Retrieves a string extra from the intent.

putParcelableExtra(String name, Parcelable

value) Passes a Parcelable object.

getParcelableExtra(String name) Retrieves a Parcelable extra.

Checks if the intent contains an extra with

hasExtra(String name)
the given name.

removeExtra(String name) Removes a specified extra from the intent.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

Method Description

startActivity(Intent intent) Starts a new activity.

startActivityForResult(Intent intent, int

requestCode) Starts an activity expecting a result.

Checks if an activity is available to handle

resolveActivity(PackageManager pm)
the intent.

2. Important Attributes in Intent Class

Attribute Description

Intent.ACTION_VIEW Opens a URI (webpage, contact, etc.).

Intent.ACTION_SEND Sends data (e.g., share text, images).

Intent.ACTION_DIAL Opens the dialer with a phone number.

Intent.ACTION_CALL Directly calls a number (requires permission).

Intent.ACTION_SENDTO Opens messaging apps for sending SMS/email.

Intent.ACTION_MAIN Launches the main activity of an app.

Intent.ACTION_EDIT Opens an app to edit content.

Intent.ACTION_PICK Selects data (e.g., contacts, images).

Intent.FLAG_ACTIVITY_NEW_TASK Starts a new activity as a task.

Clears all activities on top before launching a new

Intent.FLAG_ACTIVITY_CLEAR_TOP
one.

Intent.FLAG_GRANT_READ_URI_PERMISSION Grants temporary read access to a URI.

 Intent Filters in Android

An Intent Filter is a declaration in an Android app that allows an activity, service, or broadcast
receiver to respond to specific intents.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

1. Components of an Intent Filter

An Intent Filter consists of three main components:

1. <action> - Defines the action that the intent is performing (e.g.,

android.intent.action.VIEW).
2. <category> - Provides additional information about the intent (e.g.,
android.intent.category.DEFAULT).
3. <data> - Specifies the type of data that the intent can handle (e.g., http, content://,
file://).

2. Components in Detail

A) <action> (Required)

Defines the type of operation an intent can perform.

Common Actions Description

android.intent.action.VIEW Opens a URL, contact, or document.

android.intent.action.SEND Sends data like text or images.

android.intent.action.DIAL Opens the dialer with a phone number.

android.intent.action.CALL Directly calls a phone number (requires permission).

android.intent.action.MAIN Launches the main activity of an app.

B) <category> (Optional)

Provides additional context to the intent.

Common Categories Description

android.intent.category.DEFAULT Required for activities that respond to implicit intents.

android.intent.category.BROWSABLE Allows an activity to be opened from a web link.

android.intent.category.LAUNCHER Specifies the app's main entry point (home screen icon).

C) <data> (Optional)

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

Specifies the type of data an intent can handle.

Attribute Description

android:scheme Defines the URI scheme (e.g., http, https, mailto, tel).

android:host Specifies the host for the intent (www.example.com).

android:pathPrefix Filters specific URL paths (/product/).

android:mimeType Defines the data type (e.g., "image/*", "text/plain").

 Fragment
In Android development, a Fragment represents a reusable portion of your app's user interface.
Fragments allow for modular activity design, enabling you to divide the UI into discrete
components that can be combined in various configurations. Each fragment has its own lifecycle,
manages its own layout, and can handle its own input events. However, fragments cannot exist
independently; they must be hosted within an activity or another fragment.

Creating a Fragment:

To create a fragment, you need to perform the following steps:

1. Define the Fragment Class:

o Create a class that extends the Fragment class. Override essential lifecycle
methods such as onCreateView() to define the fragment's layout.

public class ExampleFragment extends Fragment {

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup
container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_example,
container, false);
}
}

Key Characteristics of Fragments:

 Modularity and Reusability: Fragments introduce modularity and reusability into your
activity’s UI by allowing you to divide the UI into discrete chunks. Activities are ideal
for placing global elements around your app's user interface, such as a navigation drawer,
while fragments are better suited to define and manage the UI of a single screen or
portion of a screen.

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

 Lifecycle Management: A fragment has its own lifecycle, This includes onCreate(),
onCreateView(), onStart(), onResume(), onPause(), onStop(), onDestroy() and
onDestroyView().
 Flexible UI Design: Fragments enable flexible UI designs that can adapt to various
screen sizes and orientations. For example, on larger screens like tablets, multiple
fragments can be displayed side by side, while on smaller screens like phones, fragments
can be swapped in and out to optimize the user experience.
 Communication : It can communicate with their host activity and other fragments.
 Back Stack Management : With the introduction of the Navigation component, Android
supports multiple back stacks, especially useful for apps with complex navigation
patterns like bottom navigation or navigation drawers. This feature allows users to switch
between different sections of the app without losing their navigation state in each section.
 Nested Fragment : Nested Fragments refer to fragments that are embedded within other
fragments. This hierarchical arrangement allows for more modular and flexible UI
designs, especially when dealing with complex layouts or dynamic content.

Fragment Life Cycle

1. onAttach(Context context): Called when the fragment is first attached to its context
(activity). This is where you can access the activity instance the fragment is attached to.

@Override
public void onAttach(Context context) {
super.onAttach(context);
// Initialization code here
}

2. onCreate(Bundle savedInstanceState): Invoked to do initial creation of the

fragment. Use this method to initialize essential components that you want to retain when the
fragment is paused or stopped, then resumed.

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Initialize components
}

3. onCreateView(LayoutInflater inflater, ViewGroup container, Bundle

savedInstanceState): Called to create the view hierarchy associated with the fragment.
Inflate the fragment's layout here.

@Override

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle

savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_layout, container, false);
}

4. onViewCreated(View view, Bundle savedInstanceState): Invoked immediately

after onCreateView(). Perform additional view setup here.

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
// Setup views here
}

5. onStart(): Called when the fragment becomes visible to the user.

java
CopyEdit
@Override
public void onStart() {
super.onStart();
// Fragment is visible
}

6. onResume(): Invoked when the fragment is visible and actively running.

@Override
public void onResume() {
super.onResume();
// Fragment is active
}

7. onPause(): Called when the fragment is no longer in the foreground but still visible.

@Override
public void onPause() {
super.onPause();
// Fragment is pausing
}

8. onStop(): Invoked when the fragment is no longer visible to the user.

@Override
public void onStop() {

Assistant Prof. Sunitha N CICMS

 MOBILE APPLICATION DEVELOPMENT – BCA VI SEMESTER - BCU

super.onStop();
// Fragment is stopped
}

9. onDestroyView(): Called when the view hierarchy associated with the fragment is being
removed.

@Override
public void onDestroyView() {
super.onDestroyView();
// Clean up resources related to the view
}

10. onDestroy(): Invoked to do final cleanup of the fragment's state.

@Override
public void onDestroy() {
super.onDestroy();
// Cleanup fragment resources
}

11. onDetach(): Called immediately prior to the fragment no longer being associated with its
activity.

@Override
public void onDetach() {
super.onDetach();
// Fragment is detached from activity
}

Assistant Prof. Sunitha N CICMS