Learn Flutter and Dart to Build iOS and Android Apps 2020

Video description

Get up to speed with Flutter and Dart by creating engaging mobile apps

About This Video

  • Learn Flutter and Dart from the ground up
  • Develop real-time mobile applications to understand key concepts in Flutter and Dart
  • Discover how to run code from various sources in Flutter

In Detail

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’ll 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’re ready with the set-up, you’ll build real-time mobile apps such as Quiz App and the Personal Expenses app to understand Flutter basics, the UI, widgets, styling, logic, navigation, state management, and more. You’ll also find out effective techniques to run the app on different devices such as Android, iOS, and emulators. After you’ve completed the basics, you’ll learn advanced topics such as Firebase, image picker, and push notifications by building a chat app. Toward the end, you’ll discover how to run Native Swift, Objective-C, and Java or Kotlin code, and find methods to publish your apps on app stores. By the end of this course, you’ll have the skills you need to build native mobile apps for iOS and Android.

Publisher resources

Download Example Code

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
    1. Module Introduction
    2. Creating a New Project
    3. An Overview of the Generated Files and Folders
    4. Analyzing the Default App
    5. Dart Basics
    6. More Dart Basics
    7. Building an App from Scratch
    8. Running the App on an Emulator
    9. Class Constructors and Named Arguments
    10. First Summary and Additional Syntax
    11. Building a Widget Tree
    12. Visible (Input / Output) and Invisible (Layout / Control) Widgets
    13. Adding Layout Widgets
    14. Connecting Functions and Buttons
    15. Anonymous Functions
    16. Updating Widget Data (Or Using StatelessWidget Incorrectly)
    17. Updating Correctly with StatefulWidget
    18. A Brief Look at What Flutter Actually Does
    19. Using Private Properties
    20. Creating a New Custom Widget
    21. First Styling and Layout Steps
    22. Enums and Multiple Constructors
    23. Official Docs and the Widget Catalogue
    24. Passing the Callback Functions Around
    25. Introducing Maps
    26. Mapping Lists to Widgets
    27. final vs const
    28. Introducing “if” Statements
    29. [DART DEEP DIVE] More on “if” Statements
    30. [DART DEEP DIVE] The “null” Value
    31. Outputting Widgets Conditionally
    32. Splitting the App into Widgets
    33. Calculating the Total Score
    34. Getters and “else-if”
    35. Resetting the Quiz
    36. 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 the 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. Understanding Column Alignment
    6. Not a Widget: Adding a Transaction Model and Transaction Data
    7. Mapping Data into Widgets
    8. Building a Custom List Item
    9. Styling a Container
    10. Styling Text
    11. More Styling!
    12. Containers vs Columns vs Rows
    13. Using String Interpolation
    14. Installing External Packages and Formatting Dates
    15. Adding Text Input Widgets (TextField)
    16. Fetching User Input
    17. Splitting the App into Widgets
    18. Connecting Widgets and Managing Data/State
    19. Adding User Transactions to the List
    20. Making the List Scrollable!
    21. Working with ListViews
    22. Further Input and Output Styling and Configuration
    23. Adding AppBar Buttons and Floating Action Buttons
    24. Showing a Modal Bottom Sheet
    25. Improving and Styling the Modal Bottom Sheet
    26. Configuring and Using Themes
    27. Custom Fonts and Working with Text Themes
    28. Adding Images to the App
    29. Planning the Chart Widget
    30. Looping Through Lists
    31. Deriving Recent Transactions
    32. Creating Bars for a Chart
    33. Populating a Chart with Values
    34. Finishing the Chart Bars
    35. Flexible and Expanded: Deep Dive
    36. Adding a ListTile Widget
    37. Improving the Overall Chart
    38. Widgets and Configuring Widgets - Summary/Overview
    39. Getting Started with Date Selection
    40. Showing a DatePicker
    41. Adding Transactions with a Date
    42. Deleting Transactions and Using IconButtons
    43. Final Polishing!
    44. 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. Understanding the Widget Lifecycle
    11. Understanding the App Lifecycle
    12. Understanding Context
    13. A Problem with Lists and Stateful Widgets
    14. Understanding the Problem
    15. Using Keys
    16. 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. Creating a Grid and Working with Linear Gradients
    5. Registering a Screen as the Main Screen
    6. Styling and Themes
    7. Navigating to a New Page
    8. Passing Data Through the Constructor
    9. Using Named Routes and Passing Data with Named Routes
    10. Diving Deeper into Named Routes
    11. Adding a Meal Model and Data
    12. Selecting Meals for a Chosen Category
    13. Displaying Recipe Items and Using Network Images
    14. Finishing the Meal List Item
    15. Navigating to the Meal Detail Page
    16. onGenerateRoute and onUnknownRoute
    17. Finishing the Meal Detail Page
    18. Adding a TabBar to the Appbar
    19. Adding a Bottom TabBar
    20. Adding a Custom Drawer
    21. Adding Links to the Drawer
    22. Replacing Pages (Instead of Pushing)
    23. Popping Pages and Passing Data Back
    24. Adding Filter Switches
    25. Adding Filtering Logic
    26. Adding the “Mark as Favourite” Feature
    27. A Problem!
    28. Wrap Up
  8. Chapter 8 : State Management [SHOP APP]
    1. Module Introduction
    2. Planning the App
    3. Defining a Data Model
    4. Working on the “Products” Grid and Item Widgets
    5. Styling the App and Adding a Theme to the App
    6. Adding Navigation to the App
    7. Why State Management? And What is “State” and “State Management”?
    8. Understanding the “Provider” Package and Approach
    9. Working with Providers and Listeners
    10. [DART DEEP DIVE] Inheritance (“extends”) vs Mixins (“with”)
    11. Listening in Different Places and Ways
    12. Using Nested Models and Providers
    13. Exploring Alternative Provider Syntaxes
    14. Using “Consumer” instead of “Provider.of”
    15. Local State vs App-wide State
    16. Adding Shopping Cart Data
    17. Working with Multiple Providers
    18. Connecting the Cart Provider
    19. Working on the Shopping Cart and Displaying the total
    20. Displaying a List of Cart Items
    21. Making Cart Items Dismissible
    22. Adding Product Detail Data
    23. Providing an Orders Object
    24. Adding Orders
    25. Adding an Orders Screen
    26. Using a Side Drawer
    27. Making Orders Expandable and Stateful Widgets vs Providers
    28. 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 vs 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 “Favourite” Status Optimistically
    20. Storing Orders in 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. Prepare 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 “Favourite” 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. Adding the “Add Place” Screen and an Image Input
    5. Using Image Picker and the Device Camera
    6. Storing the Image on the Filesystem (on the Device)
    7. Managing Data and Images Through the Provider Package
    8. Handling Errors
    9. Testing on Real Devices
    10. Preparing SQLite
    11. Storing and Fetching Data with SQLite
    12. Adding a Location Input and The “location” Package
    13. Fetching User Coordinates
    14. Displaying a Static Map Snapshot
    15. Rendering a Dynamic Map (using Google Maps)
    16. Allowing Users to Pick a Location on the Map
    17. Storing the Location in SQLite
    18. Adding a “Place Detail” Screen and Opening the Map in “read only” Mode
    19. 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 User Names
    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

Product information

  • Title: Learn Flutter and Dart to Build iOS and Android Apps 2020
  • Author(s): Maximilian Schwarzmüller
  • Release date: November 2018
  • Publisher(s): Packt Publishing
  • ISBN: 9781789951998