Learn Flutter and Dart to Build iOS and Android Apps (2023)

Video description

What makes Flutter the best framework to build mobile apps? With Flutter, you can build mobile apps without learning Android, Java, iOS, or Swift.

In this updated video course on Flutter, you will learn all the basic and advanced concepts needed to build amazing iOS and Android apps.

The course starts with an introduction to Flutter, guiding you through the installation process of Flutter on Windows and Mac. Once you are ready with the setup, you will build real-time mobile apps such as the Quiz app and Personal Expenses app to understand Flutter basics, the UI, widgets, styling, logic, navigation, state management, and more.

You will also find out effective techniques to run the app on different devices such as Android, iOS, and emulators. After you have completed the basics, you will learn advanced topics such as Firebase, image picker, and push notifications by building a chat app. Toward the end, you will discover how to run Native Swift, Objective-C, Java, or Kotlin code, and find methods to publish your apps on app stores.

By the end of this course, you will have the skills you need to build native mobile apps for iOS and Android.

What You Will Learn

  • Understand Flutter, Dart, and the concept behind widgets
  • Build engaging native mobile apps for both Android and iOS
  • Connect your Flutter app to back-end servers by sending HTTP requests
  • Use native device features such as the camera and Google Maps
  • Handle manual and automated push notifications
  • Publish your app on iStore and Play Store


This course is for beginners and experienced developers who are interested in delving into mobile app development using one language for both platforms. It is also ideal for experienced iOS or Android developers who want to build cross-platform (iOS and Android) apps with one single programming language. No prior knowledge of Flutter or Dart and experience of Android or iOS development is required to get started with this course.

About The Author

Academind by Maximilian Schwarzmüller:

Academind GmbH

Bundling the courses and the knowledge of successful instructors, Academind strives to deliver high-quality online education. The platform covers topics such as web development, data analysis, and more in a fun and engaging way.

Maximilian Schwarzmüller

Since the age of 13, he has never stopped learning new programming skills and languages. In his early days, he started creating websites simply for fun. This passion has remained and shaped his decision to work as a freelance web developer and consultant. Although he started web development on the backend (PHP with Laravel and NodeJS), he has progressed to becoming a front-end developer using modern frameworks such as React, Angular, and VueJS 2 in many projects.

The most rewarding experience for him is to see how people find new and better jobs, build exciting web applications, acquire amazing projects, or simply enjoy their hobby with the help of his content.

Table of contents

  1. Chapter 1 : Introduction
    1. Introduction
    2. What Is Flutter?
    3. Understanding the Flutter Architecture
    4. How Flutter and Dart Codes Get Compiled to Native Apps
    5. Understanding Flutter Versions
    6. Flutter macOS Setup
    7. macOS Development Environment
    8. Flutter Windows Setup
    9. Windows Development Environment
    10. Flutter and Material Design
    11. Flutter Alternatives
    12. Course Outline
    13. How to Get the Most Out of the Course?
  2. Chapter 2 : Flutter Basics (Quiz App)
    1. Module Introduction
    2. Creating a New Project
    3. Important - Adjusting the Starting Project
    4. An Overview of the Generated Files and Folders
    5. Analyzing the Default App
    6. Dart Basics
    7. More Dart Basics
    8. Building an App from Scratch
    9. Running the App on an Emulator
    10. Class Constructors and Named Arguments
    11. First Summary and Additional Syntax
    12. Building a Widget Tree
    13. Visible (Input/Output) and Invisible (Layout/Control) Widgets
    14. Adding Layout Widgets
    15. Connecting Functions and Buttons
    16. Anonymous Functions
    17. Updating Widget Data (Or Using StatelessWidget Incorrectly)
    18. Updating Correctly with StatefulWidget
    19. A Brief Look at What Flutter Actually Does
    20. Using Private Properties
    21. Creating a New Custom Widget
    22. First Styling and Layout Steps
    23. Enums and Multiple Constructors
    24. Official Docs and the Widget Catalogue
    25. Passing the Callback Functions Around
    26. Introducing Maps
    27. Mapping Lists to Widgets
    28. Final Versus Const
    29. Introducing "if" Statements
    30. (Dart Deep Dive) More on "if" Statements
    31. (Dart Deep Dive) The "null" Value and Null Safety
    32. Outputting Widgets Conditionally
    33. Splitting the App into Widgets
    34. Calculating the Total Score
    35. Getters and "else-if"
    36. Resetting the Quiz
    37. "New" Flutter Buttons Versus "Old" Buttons
    38. Assignment - Basics (Problem)
    39. Assignment - Basics (Solution)
    40. Wrap Up
  3. Chapter 3 : Running Apps on Different Devices and Debugging Apps
    1. Module Introduction
    2. Running the App on an Android Device
    3. Running the App on an iOS Emulator
    4. Running the App on an iOS Device
    5. Working with Emulators
    6. Understanding Error Messages and Fixing Errors
    7. Using the Debugger
    8. Getting Started with Dart DevTools
    9. Understanding the Repaint Rainbow
    10. Wrapping Up the Dart DevTools
  4. Chapter 4 : Widgets, Styling, and Adding Logic - Building a Real App (Personal Expenses App)
    1. Module Introduction
    2. An Overview of the Core Flutter Widgets
    3. Planning the App
    4. Combining Widgets
    5. Important - Adjusting the Starting Project
    6. Understanding Column Alignment
    7. Not a Widget: Adding a Transaction Model and Transaction Data
    8. Mapping Data into Widgets
    9. Building a Custom List Item
    10. Styling a Container
    11. Styling Text
    12. More Styling!
    13. Containers Versus Columns Versus Rows
    14. Using String Interpolation
    15. Installing External Packages and Formatting Dates
    16. Adding Text Input Widgets (TextField)
    17. Fetching User Input
    18. Splitting the App into Widgets
    19. Connecting Widgets and Managing Data/State
    20. Adding User Transactions to the List
    21. Making the List Scrollable!
    22. Working with ListViews
    23. Further Input and Output Styling and Configuration
    24. Adding AppBar Buttons and Floating Action Buttons
    25. Showing a Modal Bottom Sheet
    26. Improving and Styling the Modal Bottom Sheet
    27. Configuring and Using Themes
    28. Custom Fonts and Working with Text Themes
    29. Adding Images to the App
    30. Planning the Chart Widget
    31. Looping Through Lists
    32. Deriving Recent Transactions
    33. Creating Bars for a Chart
    34. Populating a Chart with Values
    35. Finishing the Chart Bars
    36. Flexible and Expanded: Deep Dive
    37. Adding a ListTile Widget
    38. Improving the Overall Chart
    39. Widgets and Configuring Widgets - Summary/Overview
    40. Getting Started with Date Selection
    41. Showing a DatePicker
    42. Adding Transactions with a Date
    43. Deleting Transactions and Using IconButtons
    44. Final Polishing!
    45. Wrap Up
  5. Chapter 5 : Responsive and Adaptive User Interfaces and Apps
    1. Module Introduction
    2. What does "Responsive" and "Adaptive" Mean?
    3. Examples: Where We Could Improve the App!
    4. Calculating Sizes Dynamically
    5. Using the LayoutBuilder Widget
    6. Controlling Device Orientation
    7. Rendering Alternative Landscape Content – 1
    8. Finishing Landscape Mode
    9. Showing Different Content Based on Device Orientation
    10. Respecting the Softkeyboard Insets
    11. Using the Device Size in Different Conditions
    12. Managing the MediaQuery Object
    13. Checking the Device Platform
    14. Using Cupertino (iOS) Widgets
    15. Using the SafeArea Class
    16. More Cupertino Styles
    17. Using Cupertino Buttons
    18. Creating Custom Adaptive Widgets
    19. Wrap Up
  6. Chapter 6 : Widget and Flutter Internals - Deep Dive
    1. Module Introduction
    2. The Problem at Hand
    3. Widget Tree and Element Tree - What, Why, and How?
    4. How Flutter Rebuilds and Repaints the Screen
    5. How Flutter Executes build ()
    6. Using "const" Widgets and Constructors
    7. Writing a Good Code
    8. Extracting Widgets
    9. Using Builder Methods
    10. Assignment - Builder Methods (Problem)
    11. Assignment - Builder Methods (Solution)
    12. Understanding the Widget Lifecycle
    13. Understanding the App Lifecycle
    14. Understanding Context
    15. A Problem with Lists and Stateful Widgets
    16. Understanding the Problem
    17. Using Keys
    18. Wrap Up
  7. Chapter 7 : Navigation and Multiple Screens (Meals App)
    1. Module Introduction
    2. Planning the App
    3. Starting with the App - Adding Base Data
    4. Important - Adjusting the Starting Project
    5. Creating a Grid and Working with Linear Gradients
    6. Registering a Screen as the Main Screen
    7. Styling and Themes
    8. Navigating to a New Page
    9. Passing Data Through the Constructor
    10. Using Named Routes and Passing Data with Named Routes
    11. Diving Deeper into Named Routes
    12. Adding a Meal Model and Data
    13. Selecting Meals for a Chosen Category
    14. Displaying Recipe Items and Using Network Images
    15. Finishing the Meal List Item
    16. Navigating to the Meal Detail Page
    17. onGenerateRoute and onUnknownRoute
    18. Finishing the Meal Detail Page
    19. Adding a TabBar to the Appbar
    20. Adding a Bottom TabBar
    21. Adding a Custom Drawer
    22. Adding Links to the Drawer
    23. Replacing Pages (Instead of Pushing)
    24. Popping Pages and Passing Data Back
    25. Adding Filter Switches
    26. Adding Filtering Logic
    27. Adding the "Mark as Favorite" Feature
    28. A Problem!
    29. Wrap Up
  8. Chapter 8 : State Management (Shop App)
    1. Module Introduction
    2. Planning the App
    3. Defining a Data Model
    4. Important - Adjusting the Starting Project
    5. Working on the "Products" Grid and Item Widgets
    6. Styling the App and Adding a Theme to the App
    7. Adding Navigation to the App
    8. Why State Management? What Is "State" and "State Management"?
    9. Understanding the "Provider" Package and Approach
    10. Working with Providers and Listeners
    11. (Dart Deep Dive) Inheritance ("extends") Versus Mixins ("with")
    12. Listening in Different Places and Ways
    13. Using Nested Models and Providers
    14. Exploring Alternative Provider Syntaxes
    15. Using "Consumer" Instead of "Provider.of"
    16. Local State Versus App-Wide State
    17. Adding Shopping Cart Data
    18. Working with Multiple Providers
    19. Connecting the Cart Provider
    20. Working on the Shopping Cart and Displaying the total
    21. Displaying a List of Cart Items
    22. Making Cart Items Dismissible
    23. Adding Product Detail Data
    24. Providing an Orders Object
    25. Adding Orders
    26. Adding an Orders Screen
    27. Using a Side Drawer
    28. Making Orders Expandable and Stateful Widgets Versus Providers
    29. Wrap Up
  9. Chapter 9 : Working with User Input and Forms (Shop App)
    1. Module Introduction
    2. Snackbars and Undoing "Add to Cart" Actions
    3. Showing Alert Dialogs
    4. Adding a "Manage Products" Page
    5. "Edit Product" Screen and a Problem
    6. Using Forms and Working with Form Inputs
    7. Managing Form Input Focus
    8. Multiline Inputs and Disposing Objects
    9. Image Input and Image Preview
    10. Submitting Forms
    11. Validating User Input
    12. Adding Validation to All Inputs
    13. Saving New Products
    14. Time to Update Products!
    15. Allowing Users to Delete Products
    16. Wrap Up
  10. Chapter 10 : Sending HTTP Requests (Shop App)
    1. Module Introduction
    2. On-Device Versus Web Storage
    3. How to Connect Flutter to a Database
    4. Preparing the Backend
    5. How to Send HTTP Requests
    6. Sending POST Requests
    7. Working with Futures in Dart
    8. (Dart Deep Dive) Futures and Async Code
    9. Showing a Loading Indicator
    10. Handling Errors Gracefully
    11. Working with "async" and "await"
    12. Fetching Data, initState and "of(context)"
    13. How to Transform Fetched Data
    14. Implementing Pull-to-Refresh
    15. Updating Data using PATCH Requests
    16. Utilizing Optimistic Updating
    17. Creating Custom Exceptions and More Error Handling
    18. A Challenge for You!
    19. Updating the "Favorite" Status Optimistically
    20. Storing Orders on the Web
    21. Fetching Orders and Fixing an Issue
    22. Using the "FutureBuilder" Widget and Improving the Code
    23. Wrap Up
  11. Chapter 11 : Adding User Authentication (Shop App)
    1. Module Introduction
    2. How Authentication Works
    3. Preparing the Backend
    4. Adding the Auth Screen
    5. Adding User Signup
    6. Allowing Users to Log In
    7. Handling Authentication Errors
    8. Managing the Auth Token Locally (in the App)
    9. Using the "ProxyProvider" and Attaching the Token to Outgoing HTTP Requests
    10. Adding Token to All Requests
    11. Connecting the "Favorite" Status to Users
    12. Attaching Products to Users and Filtering by Creator
    13. Attaching Orders to Users
    14. Adding a Logout Functionality
    15. Automatically Logging Users Out (After Some Time)
    16. Automatically Logging Users In
    17. Wrap Up
  12. Chapter 12 : Adding Animations (Shop App)
    1. Module Introduction
    2. Animations from Scratch (Completely Manually Controlled)
    3. Using the "AnimatedBuilder" Widget
    4. Working with the "AnimatedContainer"
    5. More Built-In Animation and Transition Widgets
    6. Fading Loaded Images In (and Showing a Placeholder)
    7. Adding a "Hero" Transition
    8. Working with Slivers
    9. Practice: Animating Order Boxes
    10. Implementing Custom Route Transitions
    11. Wrap Up
  13. Chapter 13 : Using Native Device Features (Such as Camera, Maps, and Location) (Great Places App)
    1. Module Introduction
    2. Planning the App
    3. PlaceList and Place Provider Setup
    4. Important - Adjusting the Starting Project
    5. Adding the "Add Place" Screen and an Image Input
    6. Using Image Picker and the Device Camera
    7. Storing the Image on the Filesystem (on the Device)
    8. Managing Data and Images Through the Provider Package
    9. Handling Errors
    10. Testing on Real Devices
    11. Preparing SQLite
    12. Storing and Fetching Data with SQLite
    13. Adding a Location Input and the "location" Package
    14. Fetching User Coordinates
    15. Displaying a Static Map Snapshot
    16. Rendering a Dynamic Map (Using Google Maps)
    17. Allowing Users to Pick a Location on the Map
    18. Storing the Location in SQLite
    19. Adding a "Place Detail" Screen and Opening the Map in "read only" Mode
    20. Wrap Up
  14. Chapter 14 : Firebase, Image Upload, Push Notification - Building a Chat App
    1. Module Introduction
    2. What Is Firebase?
    3. Creating a New App
    4. Getting Started with Firebase
    5. Getting Started with Flutter and the Firebase SDK
    6. Rendering Stream Data with StreamBuilder
    7. Adding Data
    8. A Basic Authentication Screen
    9. Adding an App Theme
    10. Creating an Authentication Form
    11. Connecting the Auth Form and Auth Screen
    12. Implementing Authentication
    13. Storing Extra User Data
    14. Completing Authentication and Logout
    15. Adding Firebase Security Rules
    16. Listening to Chat Messages
    17. Sending and Ordering Chat Messages
    18. Creating a Basic Chat Bubble Widget
    19. Improving the Chat Bubbles
    20. Testing on Multiple Devices
    21. Displaying Usernames
    22. Adding an Image Picker
    23. Preparing File Upload and Validating Images
    24. Uploading Images
    25. Improving Image Upload
    26. Running on an iOS Device
    27. Displaying User Images
    28. How Push Notifications Work
    29. An Introduction to Firebase Cloud Messaging
    30. Android and Push Notifications
    31. iOS and Push Notifications
    32. Handling Push Notifications
    33. Getting Started with Firebase Cloud Functions
    34. Setting a Firestore Trigger
    35. Sending Automated Push Notifications
    36. Polishing and Wrap Up
  15. Chapter 15 : Running Native Swift, Objective C, Java, or Kotlin Code
    1. Module Introduction
    2. Sending a Method Call from Flutter
    3. Running Android Code
    4. Running iOS Code
    5. Wrap Up
  16. Chapter 16 : Publishing to the App Stores
    1. Module Introduction
    2. Preparing the Code
    3. Preparing the App Configuration
    4. Preparing Third-Party Services
    5. Adding Icons and Splash Screens
    6. Publishing Android Apps
    7. Publishing iOS Apps
  17. Chapter 17 : Roundup and Next Steps
    1. You Did It!
    2. Your Next Steps (To Become an Awesome Developer!)
    3. How to Plan and Develop Apps Successfully
  18. Chapter 18 : Flutter 2 Update
    1. Flutter 2 – What's New? What Is the Impact on This Course?
    2. "Old" Versus "New" Button Widgets

Product information

  • Title: Learn Flutter and Dart to Build iOS and Android Apps (2023)
  • Author(s): Academind by Maximilian Schwarzmüller
  • Release date: September 2021
  • Publisher(s): Packt Publishing
  • ISBN: 9781789951998