What are Fragments and its Lifecycle?

What is a Fragment?

 

A Fragment is essentially a reusable portion of an Activity’s user interface and behavior. It encapsulates functionality that can be reused across different Activities.
Fragments can have their own layout, and they can contain UI elements like buttons, text fields, images, etc. Unlike an Activity, a Fragment cannot run independently; it must be hosted within an Activity. An Activity can contain multiple fragments, enabling complex UI designs and interaction patterns, such as tabs, navigation drawers, and responsive layouts for different screen sizes.

Why Use Fragments?

. Modular UI Components: Fragments allow for the creation of modular components that can be reused across multiple Activities or layouts. This makes the app easier to maintain and manage.

. Flexible UI Design: Fragments help create flexible layouts that adjust automatically depending on the device configuration, such as portrait and landscape modes or when switching between small and large screens (e.g., tablets).

. Separation of Concerns: Fragments help separate different functionalities within an Activity. This is particularly useful in large applications where different features or UI elements are handled by different fragments.

. Efficiency: Since fragments can be reused, they promote code reuse and efficient memory management, especially when dealing with complex UI screens.

Lifecycle of a Fragment:

The fragment lifecycle is crucial for managing the interaction between the fragment and its host Activity. It is similar to the lifecycle of an Activity but with some key differences. The lifecycle methods in the fragment lifecycle allow developers to handle the fragment’s creation, view hierarchy setup, interaction with the activity, and resource management.

1. onAttach():
This is the first callback method invoked when a fragment is attached to its host Activity. At this point, the fragment is associated with the Activity, but its view hierarchy is not yet created.
Purpose: To perform initialization tasks, such as retrieving the Activity context or passing data to the fragment before its UI is created.
Important Notes: You cannot access the fragment’s view or perform any UI-related tasks here. It is only meant for initial setup.

java code

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    // Initialize resources or interface with the activity
}

2. onCreate():
This method is called after onAttach() and before the fragment's view is created. This is where you can initialize any essential data or resources for the fragment that doesn’t depend on the view hierarchy.
Purpose: To perform fragment-specific initialization such as setting up arguments, initializing non-UI related components like adapters or data models, and saving the fragment's state.
Important Notes: The fragment’s view is still not available at this point, so avoid any view operations here.

java code

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Fragment initialization (data models, arguments)
}

3. onCreateView():

This method is called when the fragment's UI is being created. It inflates the fragment’s layout and is the ideal place to find or create the UI elements that the fragment will manage.
Purpose: To inflate and return the fragment’s layout. You should return the root view of your fragment's layout here.
Important Notes: You can access the fragment's view elements here (e.g., find view by ID).

java code

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

4. onActivityCreated():

This method is called after the fragment’s view has been created, and the activity’s onCreate() method has finished. This is where you can interact with the Activity’s UI components if needed.
Purpose: It is a safe place to interact with the host Activity after its layout is fully initialized and you can safely access the activity’s views.
Important Notes: Fragment’s views are available for interaction, but the fragment itself may not be fully visible yet.

java code

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    // Interaction with Activity’s UI or initialization of fragment’s resources
}

5. onStart():

This is when the fragment becomes visible to the user. It’s similar to the onStart() method of an Activity.
Purpose: To start any tasks that should happen when the fragment becomes visible.
Important Notes: The fragment is not yet interactive at this stage.

java code

@Override
public void onStart() {
    super.onStart();
    // Start UI-related operations that should happen when fragment is visible
}

6. onResume():

This method is called when the fragment becomes active and ready to interact with the user. At this point, the fragment is in the foreground, and user interaction is possible.
Purpose: To resume any UI updates, animations, or sensor operations that were paused in the previous state.
Important Notes: This is a great place for starting ongoing interactions (e.g., starting an animation or listening for sensor data).

java code

@Override
public void onResume() {
    super.onResume();
    // Begin user interaction, animations, etc.
}

7. onPause():

This method is called when the fragment is no longer in the foreground but is still visible (e.g., when a new fragment or Activity is on top).
Purpose: To pause ongoing operations like animations, network requests, or data updates to improve app performance.
Important Notes: Any UI updates that could consume resources should be paused here.

java code

@Override
public void onPause() {
    super.onPause();
    // Pause ongoing tasks like animations, sensors, etc.
}

8. onStop():

Called when the fragment is no longer visible to the user. This is typically when the fragment is removed from the screen, or the activity is no longer visible.
Purpose: To clean up resources or cancel tasks that should not continue when the fragment is not visible.
Important Notes: This method is useful for releasing resources such as network connections, database operations, or stopping services.

java code

@Override
public void onStop() {
    super.onStop();
    // Clean up resources
}

9. onDestroyView():

This method is called when the fragment’s view is being destroyed. It is the ideal place to clean up any view-related resources like listeners, adapters, etc.
Purpose: To release any resources related to the fragment’s view.
Important Notes: The fragment’s view is being destroyed, but the fragment itself is not yet removed.

java code

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

10. onDestroy():

This method is called when the fragment is completely destroyed. It is a good place to clean up non-view resources like background threads, database connections, or other long-running processes.
Purpose: Final cleanup of resources when the fragment is being destroyed.
Important Notes: The fragment is no longer interacting with the user.

java code

@Override
public void onDestroy() {
    super.onDestroy();
    // Clean up all resources that the fragment holds
}

11. onDetach():

The last method in the fragment’s lifecycle. It is called when the fragment is detached from the Activity.
Purpose: To clean up any references to the Activity, as the fragment is no longer attached.
Important Notes: This is the final opportunity to clean up resources related to the Activity or fragment before they are destroyed.

java code

@Override
public void onDetach() {
    super.onDetach();
    // Clean up references to the Activity
}