Android Fragment: Fragment Lifecycle In Android

Fragments are a crucial component of contemporary Android programming, whether you’re making a basic app or a sophisticated multi-pane structure. For Android developers, fragments are a significant tool that enables more flexible and adaptable user interface design. Developers can produce clean and more manageable code that is simpler to maintain and debug by breaking down large user interfaces into smaller, reusable components. In this blog, we will learn about the Android fragment, the fragment lifecycle in Android, its methods, and more.

What is Fragment in Android?

A fragment is a piece of an activity’s user interface that can be reused and merged with other fragments. It is done to form a multi-pane user interface in Android programming. It is a modular component of activity with its own user interface, behavior, and lifecycle.

Fragments offer several advantages over traditional user interface design. Following are some of these advantages:

• Simplified Code: Developers can write cleaner, more manageable code that is simpler to maintain and debug by breaking complex user interfaces into smaller bits.
• Reusability: The ability to reuse fragments across multiple activities and layouts enables a more modular design approach. It reduces the amount of time and effort required for development.
• Screen Support: Applications that can adjust to various screen sizes and orientations can be made using fragments. It makes them more adaptable and user-friendly.

Also Read: List Of Android Version

Fragment Lifecycle in Android

Understanding the fragment lifecycle is essential for Android applications that employ fragments to function effectively and efficiently. You can ensure that your pieces operate as expected and release resources when they are no longer required. This can be done by putting the proper lifecycle methods into place.

It is essential to keep in mind that the Activity lifecycle and the Fragment lifecycle are interconnected. The lifecycle methods of an activity, such as onCreate() and onDestroy, are also available to a fragment when it is added to an activity().

Android Fragment Lifecycle Methods

The fragment lifecycle in Android has the following methods:

Method	Description
onAttach()	This is the first method executed after the fragment has been linked to the activity. It is executed only once during the lifetime.
onCreate()	With this function, the fragment is initialized by adding all necessary components and attributes.
onCreateView()	This method is invoked by the system to build the fragment’s user interface.
onViewCreated()	This shows that the activity has been created where the fragment exists.
onStart()	This method is used by the system to display the fragment on the user’s device.
onResume()	This method is called to make the fragment interactive.
onPause()	It shows that the user is navigating away from the fragment.
onStop()	This is a technique to remove the fragment from the user’s screen and end its operation.
onDestroyView()	The system invokes this method to remove any resources and view hierarchies associated with the fragment.
onDestroy()	This is triggered to perform the final cleanup of the fragment and its lifecycle.
onDetach()	This approach is used by the system to separate the fragment from its host activity.

To learn more about fragment in Android and how it is used, you can opt for an Android development course.

Android Fragment Example

Here are some Android fragments examples.

Example with a Button:

This fragment contains a single button that displays a Toast message when clicked.

java

public class ButtonFragment extends Fragment implements View.OnClickListener {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

        View view = inflater.inflate(R.layout.fragment_button, container, false);
        Button button = view.findViewById(R.id.button);
        button.setOnClickListener(this);
        return view;
    }

    @Override
    public void onClick(View v) {
        Toast.makeText(getActivity(), "Button clicked", Toast.LENGTH_SHORT).show();
    }
}

2. Example with a List

This fragment displays a list of items using a RecyclerView.

public class ListFragment extends Fragment {

    private RecyclerView recyclerView;
    private List<String> itemList;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

        View view = inflater.inflate(R.layout.fragment_list, container, false);

        recyclerView = view.findViewById(R.id.recycler_view);
        recyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));

        itemList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            itemList.add("Item " + (i + 1));
        }

        ItemAdapter adapter = new ItemAdapter(itemList);
        recyclerView.setAdapter(adapter);

        return view;
    }

    private class ItemAdapter extends RecyclerView.Adapter<ItemViewHolder> {

        private List<String> itemList;

        public ItemAdapter(List<String> itemList) {
            this.itemList = itemList;
        }

        @Override
        public ItemViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            View view = LayoutInflater.from(parent.getContext())
                    .inflate(R.layout.list_item, parent, false);
            return new ItemViewHolder(view);
        }

        @Override
        public void onBindViewHolder(ItemViewHolder holder, int position) {
            holder.bind(itemList.get(position));
        }

        @Override
        public int getItemCount() {
            return itemList.size();
        }
    }

    private class ItemViewHolder extends RecyclerView.ViewHolder {

        private TextView textView;

        public ItemViewHolder(View itemView) {
            super(itemView);
            textView = itemView.findViewById(R.id.text_view);
        }

        public void bind(String text) {
            textView.setText(text);
        }
    }
}

Also Read: How To Become An Android Developer

3. Example with a WebView

This fragment displays a WebView that loads a web page.

public class WebFragment extends Fragment {

    private WebView webView;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

        View view = inflater.inflate(R.layout.fragment_web, container, false);
        webView = view.findViewById(R.id.web_view);
        webView.loadUrl("https://www.google.com");
        return view;
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        webView.destroy();
    }
}

Benefits of Using Fragments in Android

There are several benefits of using Android fragments. Some of them are:

• Modern UI

With the use of fragments, UIs can be built in a modular manner. This breaks down huge screens into manageable and reusable parts. It makes it simpler to reuse UI components across several screens and to manage complicated UIs.

• Improved Performance

By loading only the necessary UI components when required, fragments allow developers to optimize the performance of their apps. This helps consume less memory.

• Flexibility

Fragments are easy to add, remove, and change. Hence, making it simple to handle various user interactions and adapt to various screen sizes.

• Easy Development

Developers can make their code less complex by utilizing fragments, making it easier to maintain and upgrade their apps over time.

• User Experience

Fragments can be leveraged to create a more dynamic and engaging user experience. It can happen by enabling users to toggle between various UI elements via swipe motions or tabs.

Conclusion

Android fragment is an essential part of Android programming that helps break down activities and user interfaces into multiple fragments. It helps create intricate, adaptable, and modular interfaces that are easy to understand and maintain. Also, by simplifying the code, fragments make it simpler to maintain and troubleshoot.