Flutter Simple Calculator: Learn How to Build Your First Flutter App

Welcome to the Flutter tutorial!

Today, we're going to dive into the exciting world of Flutter development by creating a simple yet functional calculator app.

In this guide, we will walk you through the creation of a Flutter simple calculator. This project aims to familiarize you with the fundamental concepts of Flutter while building a simple calculator. This calculator app will allow users to perform basic arithmetic operations such as addition, subtraction, multiplication, and division.

Key features of the basic calculator app include:

• A clean and user-friendly interface.

• Responsive design that works on various

Setting Up Your Flutter Development Environment

Installing Flutter SDK

To begin developing a basic calculator app using Flutter, you first need to install the Flutter SDK. Here’s a step-by-step guide to help you through the process:

1. Download the Flutter SDK:

   • Visit the Flutter installation page and get the SDK for your operating system (Windows, macOS, or Linux).

2. Extract the Downloaded File:

   • Extract the zip file to a desired location on your system. For example, on Windows, you might extract it to C:\src\flutter.

3. Update the System Path:

   • Add the Flutter bin directory to your system PATH. This allows you to run Flutter commands from any terminal window.

   • On Windows:

     1. Search for "Environment Variables" in the Start Menu.

     2. Select "Edit the system environment variables".

     3. Click on "Environment Variables".

     4. Under "System variables", find the PATH variable and click "Edit".

     5. Add the full path to the flutter/bin directory.

   • On macOS and Linux:

     ◦ Open your .bashrc, .bash_profile, or .zshrc file and add the following line:

Copy
1
export PATH="$PATH:`pwd`/flutter/bin"

4. Run Flutter Doctor:

   • Open a new terminal window and run the following command to verify your installation:

Copy
1
flutter doctor

• This command checks your environment and displays a report of the status of your Flutter installation.

Setting Up an IDE

To make your Flutter development experience smoother, it's recommended to use an Integrated Development Environment (IDE). The two most popular IDEs for Flutter development are Android Studio and Visual Studio Code.

Android Studio

1. Install Android Studio:

   • Download and install Android Studio from the official website .

2. Set Up Flutter Plugin:

   • Open Android Studio.

   • Go to File > Settings (or Android Studio > Preferences on macOS).

   • Select Plugins and search for Flutter and Dart plugins. Install both plugins and restart Android Studio.

3. Configure Android Studio:

   • Open Android Studio and go to Configure > SDK Manager.

   • Ensure the latest Android SDK and Virtual Device are installed.

   • Configure the AVD (Android Virtual Device) for testing your Flutter apps.

Visual Studio Code

1. Install Visual Studio Code:

   • Download and install Visual Studio Code from the official website .

2. Set Up Flutter Extension:

   • Open Visual Studio Code.

   • Go to the Extensions view by clicking on the Extensions icon in the Activity Bar or pressing Ctrl+Shift+X.

   • Search for Flutter and install the Flutter extension by Dart Code. This will also install the Dart extension.

3. Configure Visual Studio Code:

   • Open the Command Palette by pressing Ctrl+Shift+P and run the Flutter: New Project command to create a new Flutter project.

   • Use the integrated terminal in Visual Studio Code to run and debug your Flutter apps.

By following these steps, you will have a fully functional development environment set up for building your basic calculator app using Flutter.

Creating the Flutter Project

Initializing a New Flutter Project

To start creating your basic calculator app, you need to initialize a new Flutter project. This is done using the Flutter command-line tools.

Command to Create a New Project

1. Open a Terminal or Command Prompt:

   • Ensure that Flutter is installed and added to your system PATH.

2. Run the Flutter Create Command:

Use the following command to create a new Flutter project:

Copy
1
flutter create calculator_app

Replace calculator_app with your desired project name. This command will generate a new Flutter project with the necessary files and folders.

Overview of the Generated Project Structure

Once the project is created, you will see a directory structure similar to this:

• lib: This directory contains the main code for your Flutter app. The main.dart file is where the app execution starts.

• android: This directory contains the Android-specific configuration and code.

• ios: This directory contains the iOS-specific configuration and code.

• test: This directory contains the unit tests for your Flutter app.

• pubspec.yaml: This file manages the project's dependencies and other configurations.

Here is a brief overview of the key files and directories:

• lib/main.dart: The entry point for your Flutter application.

• pubspec.yaml: The file where you define the dependencies for your project.

• android: Contains Android-specific files, including the AndroidManifest.xml.

• ios: Contains iOS-specific files, including the Info.plist.

Running the Default App

After initializing the new Flutter project, you can run the default app to ensure everything is set up correctly.

Running the Default Flutter App

1. Navigate to the Project Directory:

Copy
1
cd calculator_app

2. Run the App:

Open a new terminal window and run the following command to verify your installation:

Copy
1
flutter doctor

This command checks your environment and displays a report of the status of your Flutter installation.

Understanding the Default Code Structure

The default Flutter app contains a simple counter application. Here’s an overview of the main.dart file:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;

  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            const Text(
              'You have pushed the button this many times:',
            ),
            Text(
              '$_counter',
              style: Theme.of(context).textTheme.headlineMedium,
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _incrementCounter,
        tooltip: 'Increment',
        child: const Icon(Icons.add),
      ),
    );
  }
}

• void main(): The entry point of the application.

• MyApp: A stateless widget that sets up the app’s theme and home screen.

• MyHomePage: A stateful widget that manages the app’s state and displays a counter.

By understanding this basic structure, you can start modifying it to develop your basic calculator app using Flutter. This will involve creating additional widgets and implementing the logic for the calculator operations.

Building the Calculator UI

Designing the User Interface

Developing an intuitive and visually appealing user interface (UI) is critical for your basic calculator software. Here’s a step-by-step guide on planning the UI layout and adding the necessary widgets for buttons and displays.

Planning the UI Layout

For a basic calculator app, the UI should include:

1. Display Area: To show the input numbers and results.

2. Buttons: For digits (0-9), operations (addition, subtraction, multiplication, division), and functionalities like clear (C) and equals (=).

The layout can be structured using a combination of Column and Row widgets to arrange the buttons in a grid format.

Adding Widgets for Buttons and Display

1. Display Area:

   • Use a Container widget to create a display area at the top of the screen. This container will hold a Text widget to display the input and result.

2. Buttons:

   • Use RaisedButton or ElevatedButton widgets for the calculator buttons.

   • Arrange the buttons using Row and Column widgets within a GridView or Table widget for a structured layout.

Here’s a basic layout plan:

• A Column widget as the main container.

• A Container at the top for the display area.

• Multiple Row widgets within a GridView for the buttons.

Implementing the Layout

Now, let's write the code for the main layout of the simple calculator app using Flutter widgets.

Writing the Code for the Main Layout

1. Creating the Main Layout:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import 'package:flutter/material.dart';

void main() {
  runApp(const CalculatorApp());
}

class CalculatorApp extends StatelessWidget {
  const CalculatorApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        appBar: AppBar(title: const Text('Simple Calculator')),
        body: const Calculator(),
      ),
    );
  }
}

class Calculator extends StatefulWidget {
  const Calculator({Key? key}) : super(key: key);

  @override
  _CalculatorState createState() => _CalculatorState();
}

class _CalculatorState extends State<Calculator> {
  String _output = "0";

  Widget buildButton(String buttonText) {
    return Expanded(
      child: OutlinedButton(
        onPressed: () {
          // Handle button press
        },
        child: Text(
          buttonText,
          style: const TextStyle(fontSize: 20.0),
        ),
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: <Widget>[
        Container(
          alignment: Alignment.centerRight,
          padding: const EdgeInsets.symmetric(
            vertical: 24.0,
            horizontal: 12.0,
          ),
          child: Text(
            _output,
            style: const TextStyle(
              fontSize: 48.0,
              fontWeight: FontWeight.bold,
            ),
          ),
        ),
        const Expanded(child: Divider()),
        Column(
          children: [
            Row(
              children: [
                buildButton("7"),
                buildButton("8"),
                buildButton("9"),
                buildButton("/"),
              ],
            ),
            Row(
              children: [
                buildButton("4"),
                buildButton("5"),
                buildButton("6"),
                buildButton("*"),
              ],
            ),
            Row(
              children: [
                buildButton("1"),
                buildButton("2"),
                buildButton("3"),
                buildButton("-"),
              ],
            ),
            Row(
              children: [
                buildButton("."),
                buildButton("0"),
                buildButton("00"),
                buildButton("+"),
              ],
            ),
            Row(
              children: [
                buildButton("C"),
                buildButton("="),
              ],
            ),
          ],
        )
      ],
    );
  }
}

Using Flutter Widgets for the Calculator Interface

• Column Widget: The main layout container that holds the display and buttons.

• Container Widget: Used for the display area to show the input and results.

• Row Widget: Used to arrange buttons in horizontal lines.

• OutlinedButton Widget: Used for the calculator buttons to perform actions when pressed.

This basic structure provides a foundation to build upon by adding the necessary functionality to handle user interactions and perform calculations. By organizing your layout using Column and Row widgets, and styling your buttons with OutlinedButton widgets, you can create a visually appealing and functional simple calculator app using Flutter.

Implementing Calculator Logic

Handling User Input

To make your calculator app functional, you must handle user input effectively. This involves capturing button presses and updating the display accordingly.

Capturing Button Presses

You need to modify the buildButton method to capture button presses and update the internal state of the calculator. Here’s how to handle button presses:

Update the _CalculatorState class to handle different types of button presses such as numbers, operators, and special buttons like "C" (clear) and "=" (equals).

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
import 'package:flutter/material.dart';

void main() {
  runApp(const CalculatorApp());
}

// Define the CalculatorApp class
class CalculatorApp extends StatelessWidget {
  const CalculatorApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: const Calculator(),
    );
  }
}

// Define the Calculator StatefulWidget
class Calculator extends StatefulWidget {
  const Calculator({Key? key}) : super(key: key);

  @override
  _CalculatorState createState() => _CalculatorState();
}

// The existing _CalculatorState class
class _CalculatorState extends State<Calculator> {
  String _output = "0";
  String _result = "0";
  String _operation = "";
  double num1 = 0.0;
  double num2 = 0.0;

 void buttonPressed(String buttonText) {
  if (buttonText == "C") {
    _output = "0";
    _result = "0";
    num1 = 0.0;
    num2 = 0.0;
    _operation = "";
  } else if (buttonText == "+" || buttonText == "-" || buttonText == "/" || buttonText == "*") {
    num1 = double.tryParse(_output) ?? 0.0;
    _operation = buttonText;
    _output = "0";
  } else if (buttonText == "=") {
    num2 = double.tryParse(_output) ?? 0.0;
    switch (_operation) {
      case "+":
        _result = (num1 + num2).toString();
        break;
      case "-":
        _result = (num1 - num2).toString();
        break;
      case "*":
        _result = (num1 * num2).toString();
        break;
      case "/":
        _result = num2 != 0 ? (num1 / num2).toString() : "Error";
        break;
      default:
        break;
    }
    _output = _result;
    _operation = "";
    num1 = 0.0;
    num2 = 0.0;
  } else {
    // Check if _output is "0" and the button pressed is a number
    if (_output == "0" && buttonText != ".") {
      _output = buttonText;
    } else {
      _output += buttonText;
    }
  }
  setState(() {
    _output = _output;
  });
}

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Calculator"),
      ),
      body: Column(
        children: <Widget>[
          Container(
            alignment: Alignment.centerRight,
            padding: const EdgeInsets.symmetric(vertical: 24.0, horizontal: 12.0),
            child: Text(
              _output,
              style: const TextStyle(fontSize: 48.0, fontWeight: FontWeight.bold),
            ),
          ),
          const Expanded(child: Divider()),
          ..._buildCalculatorButtons(),
        ],
      ),
    );
  }

  List<Widget> _buildCalculatorButtons() {
    // This function builds buttons in a more scalable way
    List<List<String>> buttons = [
      ["7", "8", "9", "/"],
      ["4", "5", "6", "*"],
      ["1", "2", "3", "-"],
      [".", "0", "00", "+"],
      ["C", "="]
    ];
    return buttons.map((List<String> row) {
      return Row(
        children: row.map((String buttonText) {
          return buildButton(buttonText);
        }).toList(),
      );
    }).toList();
  }

  Widget buildButton(String buttonText) {
    return Expanded(
      child: OutlinedButton(
        onPressed: () => buttonPressed(buttonText),
        child: Text(
          buttonText,
          style: const TextStyle(fontSize: 20.0),
        ),
      ),
    );
  }
}

​

Conclusion

We have successfully created a Flutter simple calculator in this step-by-step guide. We started by setting up the Flutter development environment, including installing the Flutter SDK and configuring an IDE. We then initialized a new Flutter project, explored its default structure, and built the calculator UI using various Flutter widgets.

Finally, we implemented the core logic for handling user input and performing arithmetic operations. With this foundation, you can now explore more advanced features and enhancements to expand the functionality of your calculator app, delving deeper into the exciting world of Flutter development.