Master the Art of Refactoring Flutter Widgets

Master the Art of Refactoring Flutter Widgets

Table of Contents

1. Introduction
2. Extracting and Refactoring Widgets
   • Consolidating Repeated Widget Code
   • Designing the User Interface
   • Creating the Skeleton
   • Creating the Background Cards
   • Adjusting the Size and Margins
   • Adding Rounded Corners to the Cards
   • Using Expanded Widgets for Responsive Layout
   • Building the Column and Row Structure
   • Refactoring Code for Reusability
   • Customizing the Reusable Card Widget
   • Making the Color Property Required
3. Conclusion

Extracting and Refactoring Widgets for Improved Code Reusability

In this lesson, we will explore the process of extracting and refactoring widgets to improve code reusability. As our applications become more complex, it becomes necessary to identify repeated parts in the widget tree and consolidate them into a single widget. By doing so, we can easily reuse this widget throughout our app when we require the same appearance or functionality.

Consolidating Repeated Widget Code

When developing complex apps, we often encounter scenarios where certain parts of the widget tree are repeated. This creates redundancy and leads to bloated code. To overcome this, we can extract these repeated parts as separate classes, known as reusable widgets.

Designing the User Interface

Before we can extract and refactor widgets, we need to design the user interface. The first step in creating the UI is to Create the skeleton - individual cards that act as components or areas. These cards serve as the background for different sections and help the user differentiate between various parts.

Creating the Skeleton

To create the skeleton, we start by adding a container widget as the background for each area. We define the color of the container using a hex code that matches the design specifications. Additionally, we set a specific Height and width for the container to ensure consistency throughout the app.

Creating the Background Cards

To give the cards a visually appealing look, we Apply a margin to create a separation between them. A margin of around 15 pixels on all sides works well in most cases. We also add a border radius to give the edges of the cards a rounded appearance, making them more visually pleasing and friendly.

Adjusting the Size and Margins

To ensure that the layout adapts to different screen sizes and orientations, we need to make it responsive. One way to achieve this is by using expanded widgets, which automatically adjust their size Based on the available space. By using expanded widgets, we can easily create a layout that fits the screen without overflowing or causing scrollbars.

Building the Column and Row Structure

The overall layout of the screen is mainly composed of columns and rows. We have a column that contains three expanded widgets, each representing a row. In the first and last row, we have a row widget that contains two expanded widgets. This structure allows us to arrange the cards in a stack, providing an organized and visually pleasing interface.

Refactoring Code for Reusability

At this point, we have a repetitive code for the container that acts as the background for each card. To avoid code duplication and follow the best programming practices, we can extract this code into a separate class called a reusable card. Extracting the widget helps keep our code dry (don't repeat yourself) and improves readability and maintainability.

Customizing the Reusable Card Widget

The reusable card widget can be customized to suit different requirements. In our example, we focus on customizing the background color of the card. By specifying the color property when creating a new reusable card widget, we can easily change its appearance. This allows us to create cards with different colors and Show visual indicators based on user interactions.

Making the Color Property Required

To ensure that the color property is always provided when creating a reusable card, we can make it a required parameter in the constructor. By adding the required keyword before the property, we enforce that the constructor must receive a color value. This helps prevent null values and ensures consistency in the application.

Conclusion

Extracting and refactoring widgets is a crucial step in maintaining scalable and reusable code in Flutter. By identifying repeated parts in the widget tree and consolidating them into separate classes, we improve code reusability, reduce redundancy, and enhance the overall maintainability of our application. The process involves designing the user interface, creating the skeleton, adjusting the size and margins, building the column and row structure, and finally refactoring the code for reusability. Customizing the widgets allows us to create diverse and visually appealing interfaces.