Fragments in Android: A Comprehensive Guide

Fragments in Android have revolutionised Mobile App Development, providing a dynamic and modular way to design User Interfaces. Have you ever wondered how modern apps seamlessly switch between screens without fully reloading or adapting to different screen sizes? The magic lies in fragments. 

Unlike traditional activities, fragments are self-contained sections within an activity, making them ideal for creating flexible, multi-pane layouts and enabling dynamic UI changes at runtime. In this blog, we’ll explore what fragments are, why they’re essential, and how you can use them to build more modular, reusable, and efficient Android app 

Table of Contents 

1) What Are Fragments in Android? 

2) Why Do We Need Android Fragments? 

3) Lifecycle Methods of Android Fragments 

4) Types of Fragments in Android 

5) How to Use Fragments in Android? 

6) Example of Android Fragment 

7) Working With Android Fragments and Activities 

8) Creating Fragments in Android 

9) Conclusion 

What Are Fragments in Android? 

A Fragment in Android is a modular section of an activity that represents a portion of the User Interface. It is a reusable component that can exist independently within an activity, allowing you to manage different parts of the UI separately. Essentially, a fragment acts as a “sub-activity” that can combine with other fragments to form a complete User Interface. 

A fragment can be thought of as a building block, allowing developers to create more complex and flexible layouts. Each fragment has its own lifecycle, events, and methods that work in conjunction with subordinating conjunctions in its parent activity. This modularity makes fragments incredibly useful for applications that need to adapt to various screen sizes, like smartphones and tablets.

 

Why Do We Need Android Fragments? 

Android Fragments are essential for creating flexible and adaptable User Interfaces (UI) in Android applications. Prior to their introduction, developers relied solely on activities to manage UIs, which led to monolithic designs that were less flexible and harder to maintain. Fragments allow for better modularity, responsiveness, and reusability, helping developers create apps that can adapt to various device configurations and user interactions. 

Some key benefits of using Android Fragments include: 

1) Modularity: Fragments break down the UI into smaller, reusable components, making the code more manageable and easier to maintain. 

2) Responsiveness: Fragments enable dynamic layouts that can adjust to different screen sizes, orientations, or device configurations, improving the overall user experience. 

3) Reusability: Fragments can be reused across different activities, reducing redundancy and making the app more efficient and scalable. 

Lifecycle Methods of Android Fragments 

Just like activities, fragments follow a lifecycle consisting of a series of methods that dictate the state of the fragment at any given point. Understanding the lifecycle of fragments is crucial to ensure proper resource management and UI handling. The lifecycle methods of a fragment include: 

1) onAttach: Called when the fragment is associated with its parent activity. 

2) onCreate: Used to initialise the fragment and set up non-UI related components. 

3) onCreateView: Called when the fragment needs to create its UI, usually inflating the layout from XML. 

4) onActivityCreated: Called when the fragment’s parent activity has completed its own onCreate method. 

5) onStart: The fragment becomes visible but might not yet be interactable. 

6) onResume: The fragment is fully visible and ready for user interaction. 

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

8) onStop: The fragment is no longer visible to the user. 

9) onDestroyView: Called to clean up resources and remove the fragment's view. 

10) onDetach: The fragment is detached from its parent activity. 

Understanding these methods is key to managing your fragment's state and ensuring that you create robust and responsive applications. 

Types of Fragments in Android 

Android Fragments come in different types, each serving a unique purpose depending on the layout and UI needs of the application. Let’s explore some of the common types of Fragments in Android. 

1) Handling Fragment Transactions 

A fragment transaction is the process of adding, removing, or replacing fragments in an activity dynamically. Fragment transactions are key to creating dynamic UIs where fragments can be switched based on user input or other conditions. This process is managed through the “FragmentManager” class, which handles fragment operations. 

The most common methods used in fragment transactions include “add()”, “replace()”, “remove()”, and “commit()”. 

2) List Fragments in Android 

List fragments are specialized fragments that display a list of items. These fragments are particularly useful for creating menus, navigation elements, or any list-based UI. A “ListFragment” handles much of the heavy lifting involved in displaying a list, allowing developers to focus more on the content. Similarly, when turning off voicemail on Android, developers can utilize system settings to simplify the process, allowing users to focus on other phone features.

The “onListItemClick” method is triggered when a user selects an item from the list, which allows developers to define actions based on the selection. 

3) Single Fragments in Android 

Single fragments are simpler, self-contained fragments that represent a single portion of an activity's UI. These fragments are ideal for use cases where you don’t need multiple fragments interacting or where only a single, static UI is needed. For example, a fragment displaying detailed information about an item selected from a list can be a single fragment. 

How to Use Fragments in Android? 

Using Fragments in Android is straightforward once you understand their lifecycle and types. Typically, you start by creating a fragment class, either by extending “Fragment” or one of its subclasses (like “ListFragment”). You then define the fragment's layout in an XML file and inflate it in the fragment’s “onCreateView” method. 

To use fragments within an activity, you'll need to define placeholders in the activity’s layout file and use the “FragmentManager” to dynamically add or replace fragments during runtime. 

Here’s an outline of the steps: 

1) Create a fragment by extending the Fragment. 

2) Inflate the layout in “onCreateView”. 

3) Use “FragmentManager” to handle fragment transactions. 

Unlock Your Developer Potential! Dive into our Android App Development Course and start building amazing apps today. Join now! 

Example of Android Fragment 

Let’s walk through a simple example of creating and using a fragment. Assume you want to create a fragment that displays a text message. 

Step 1: Create the Fragment Class
 

public class ExampleFragment extends Fragment {      @Override      public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {          return inflater.inflate(R.layout.fragment_example, container, false);      }  }

 

Step 2: Define the Layout (fragment_example.xml)
 

android:layout_width="match_parent"      android:layout_height="match_parent"      android:orientation="vertical">             android:id="@+id/text_view"          android:layout_width="wrap_content"          android:layout_height="wrap_content"          android:text="Hello, Fragment!" />

Step 3: Add the Fragment to the Activity 

In your activity’s layout file, you can add a placeholder for the fragment:
 

android:id="@+id/fragment_container"      android:layout_width="match_parent"      android:layout_height="match_parent" />

Then, add the fragment programmatically in the activity:
 

FragmentManager fragmentManager = getSupportFragmentManager();  FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();  ExampleFragment fragment = new ExampleFragment();  fragmentTransaction.add(R.id.fragment_container, fragment);  fragmentTransaction.commit();

Working with Android Fragments and Activities

Fragments and activities work together, and there are two primary methods for managing fragments within an activity: 

1) Static Method

In the static method, you declare fragments directly in the XML layout of the activity. This is useful when you know in advance that the fragment will always be part of the activity's layout and won’t change dynamically. 

Example:
 

android:id="@+id/static_fragment"      android:name="com.example.StaticFragment"      android:layout_width="match_parent"      android:layout_height="wrap_content" />

 

2) Dynamic Method

In the dynamic method, fragments are added or replaced programmatically during runtime, allowing for more flexible and dynamic layouts. This is done using “FragmentManager” and “FragmentTransaction”, as demonstrated in the example earlier.

Want to modify your location on Android? Follow our step-by-step guide on How to Change Location on Android!

Creating Fragments in Android 

Creating Fragments in Android is a relatively simple process. As we saw in the example, you need to extend the “Fragment” class, inflate the layout, and manage the lifecycle. Creating Fragments in Android involves a few straightforward steps. Here’s a simple breakdown of the process: 

1) Extend the Fragment Class 

Start by creating a new class that extends the “Fragment” class (or its subclasses like “ListFragment”). This will be your custom fragment.
 

public class ExampleFragment extends Fragment {  }

 

2) Override the onCreateView Method 

Inside the fragment class, override the “onCreateView” method. This method is responsible for inflating the layout for your fragment and returning the view to the parent activity.
 

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

3) Create a Layout for the Fragment 

Define the layout for your fragment in an XML file. This layout will be inflated when the fragment is created. You can include any UI elements you need within this layout.
 

android:layout_width="match_parent"      android:layout_height="match_parent"      android:orientation="vertical">          android:id="@+id/text_view"          android:layout_width="wrap_content"          android:layout_height="wrap_content"          android:text="Hello, Fragment!" />

4) Add the Fragment to the Activity 

You can add the fragment to your activity either statically (using XML) or dynamically (programmatically). For dynamic addition, use “FragmentManager” and “FragmentTransaction” in your activity. 

Dynamically:
 

FragmentManager fragmentManager = getSupportFragmentManager();  FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();  ExampleFragment fragment = new ExampleFragment();  fragmentTransaction.add(R.id.fragment_container, fragment);  fragmentTransaction.commit();

Statically (in XML):
 

android:id="@+id/fragment_example"      android:name="com.example.ExampleFragment"      android:layout_width="match_parent"      android:layout_height="wrap_content" />

5) Handle Fragment Lifecycle Methods 

Ensure that you manage the fragment’s lifecycle by using lifecycle methods such as “onAttach”, “onCreate”, “onCreateView”, “onStart”, “onResume”, etc., as needed. 

6) Enable Fragment-Activity Communication (Optional) 

If your fragment needs to communicate with the parent activity, implement an interface in the fragment class. The parent activity will then implement this interface to receive data or handle fragment events. 

In Fragment:
 

public interface OnFragmentInteractionListener {      void onFragmentInteraction(String data);  } private OnFragmentInteractionListener listener;  @Override  public void onAttach(Context context) {      super.onAttach(context);      if (context instanceof OnFragmentInteractionListener) {          listener = (OnFragmentInteractionListener) context;      } else {          throw new RuntimeException(context.toString() + " must implement OnFragmentInteractionListener");      }  }  // Use listener to send data to the parent activity  listener.onFragmentInteraction("Data from Fragment");

7) Test and Deploy 

Once your fragment is created, test it within the activity to ensure that it works as expected. Make sure to test for lifecycle handling and fragment communication. 

Code Your Dreams! Join our Mobile App Development Training and start building innovative apps that make a difference.

Conclusion

Fragments are a vital part of modern Android Development, allowing developers to create more modular, flexible, and responsive User Interfaces. From understanding the lifecycle of fragments to managing fragment transactions and integrating them with activities, this blog provides you with the knowledge needed to master Fragments in Android. 

Ready to master Web Development? Learn to build responsive, dynamic websites with our expert-led Web Development Training – Join now