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

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