Learn Flutter & Dart to Build iOS & Android Apps

Learn Flutter & Dart to Build iOS & Android Apps
Learn Flutter & Dart to Build iOS & Android Apps
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 58.5 Hours | 37.7 GB

A Complete Guide to the Flutter SDK & Flutter Framework for building native iOS and Android apps

Join the most comprehensive & bestselling Flutter course and learn how to build amazing iOS and Android apps!

You don’t need to learn Android/ Java and iOS/ Swift to build real native mobile apps!

Flutter – a framework developed by Google – allows you to learn one language (Dart) and build beautiful native mobile apps in no time. Flutter is a SDK providing the tooling to compile Dart code into native code and it also gives you a rich set of pre-built and pre-styled UI elements (so called widgets) which you can use to compose your user interfaces.

Flutter is extremely trending and gets used for major Google apps like their Adwords app – it’s now marked as “ready for production”, hence now is the time to jump in and learn it!

This course will teach Flutter & Dart from scratch, NO prior knowledge of either of the two is required! And you certainly don’t need any Android or iOS development experience since the whole idea behind Flutter is to only learn one language.

You’ll learn Flutter not only in theory but we’ll build a complete, realistic app throughout this course. This app will feature both all the core basics as well as advanced features like using Google Maps, the device camera, adding animations and more!

With Flutter, you’ll be able to write code only once and ship your apps both to the Apple AppStore and Google Play.

Use Google’s Material Design to build beautiful, yet fully customizable, apps in no time with almost zero effort. You can use the rich widget suite Flutter provides to add common UI elements like buttons, switches, forms, toolbars, lists and more – or you simply build your own widgets – Flutter makes that a breeze, too.

Here’s what’s included in the course:

  • Detailed setup instructions for both macOS and Windows
  • A thorough introduction to Flutter, Dart and the concept behind widgets
  • An overview of the built-in widgets and how you may add your own ones
  • Debugging tipps & tricks
  • Page navigation with tabs, side drawers and stack-based navigation
  • State management solutions
  • Handling and validating user input
  • Connecting your Flutter app to backend servers by sending Http requests
  • User authentication
  • Adding Google Maps
  • Using native device features like the camera
  • Adding beautiful animations & page transitions
  • How to publish your app to the app stores
  • And more!

What you’ll learn

  • Build engaging native mobile apps for both Android and iOS
  • Use features like Google Maps, the device camera, authentication and much more!
  • Learn all the basics and advanced features which you find in no other course
Table of Contents

Introduction
1 Introduction
2 What is Flutter?
3 Understanding the Flutter Architecture
4 How Flutter & Dart Code Gets 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 & Material Design
11 Flutter Alternatives
12 Course Outline
13 How To Get The Most Out Of The Course
14 Useful Resources & Links

Flutter Basics [QUIZ APP]
15 Module Introduction
16 Creating a New Project
17 An Overview of the Generated Files & Folders
18 More on Git (Version Control System)
19 Analyzing the Default App
20 Dart Basics
21 More Dart Basics
22 Dart Basics – Summary
23 Building an App From Scratch
24 Running the App on an Emulator
25 Class Constructors & Named Arguments
26 First Summary & Additional Syntax
27 Building a Widget Tree
28 Visible (Input / Output) & Invisible (Layout / Control) Widgets
29 Adding Layout Widgets
30 Connecting Functions & Buttons
31 Anonymous Functions
32 Updating Widget Data (Or: Using StatelessWidget Incorrectly)
33 [DART DEEP DIVE] Understanding Lists
34 Updating Correctly with Stateful Widgets
35 A Brief Look Under The Hood
36 Using Private Properties
37 Creating a New, Custom Widget
38 First Styling & Layouting Steps
39 Enums & Multiple Constructors
40 Official Docs & The Widget Catalog
41 Passing Callback Functions Around
42 Introducing Maps
43 Mapping Lists to Widgets
44 final vs const
45 Introducing “if” Statements
46 [DART DEEP DIVE] More on “if” Statements
47 [DART DEEP DIVE] The “null” Value
48 Outputting Widgets Conditionally
49 Splitting the App Into Widgets
50 Calculating a Total Score
51 Getters & “else-if”
52 Resetting the Quiz
53 Wrap Up
54 Module Resources

Running Apps on Different Devices & Debugging Apps
55 Module Introduction
56 Running the App on a Real Android Device
57 Running the App on an iOS Emulator
58 Running the App on a Real iOS Device
59 Working with the Emulators / Using the Emulators
60 Understanding Error Messages & Fixing Errors
61 Using the Debugger
62 Getting Started with the Dart DevTools
63 Understanding the Repaint Rainbow
64 Wrapping up the Dart DevTools
65 Useful Resources & Links

Widgets, Styling, Adding Logic – Building a Real App [PERSONAL EXPENSES APP]
66 Module Introduction
67 An Overview of the Core Flutter Widgets
68 Planning the App
69 Combining Widgets
70 Understanding Column Alignment
71 Not a Widget: Adding a Transaction Model & Transaction Data
72 Mapping Data Into Widgets
73 Building a Custom List Item
74 Styling a Container
75 Styling Text
76 More Styling!
77 Containers vs Columns vs Rows
78 Using String Interpolation
79 Installing External Packages & Formatting Dates
80 DateFormat Patterns
81 Adding Text Input Widgets (TextField)
82 Fetching User Input
83 Splitting the App Into Widgets
84 Connecting Widgets & Managing Data / State
85 Adding User Transactions to the List
86 Making the List Scrollable!
87 Working with ListViews
88 Further Input & Output Styling and Configuration
89 Adding AppBar Buttons & Floating Action Buttons
90 Showing a Modal Bottom Sheet
91 Improving & Styling the Modal Bottom Sheet
92 Configuring & Using Themes
93 Custom Fonts & Working with Text Themes
94 Adding Images to the App
95 Planning the Chart Widget
96 Looping Through Lists
97 More on “for” Loops
98 Deriving Recent Transactions
99 Creating Bars for our Chart
100 Populating the Chart with Values
101 Finishing the Chart Bars
102 Flexible & Expanded: Deep Dive
103 Adding a ListTile Widget
104 Improving the Overall Chart
105 Widgets & Configuring Widgets – Summary / Overview
106 Getting Started with Date Selection
107 Showing a DatePicker
108 Adding Transactions with a Date
109 Deleting Transactions & Using IconButtons
110 Final Polishing!
111 Wrap Up
112 Useful Resources & Links

Responsive & Adaptive User Interfaces and Apps
113 Module Introduction
114 What does “Responsive” and “Adaptive” Mean?
115 Examples: Where we could improve the App!
116 Calculating Sizes Dynamically
117 Working with the “textScaleFactor”
118 Using the LayoutBuilder Widget
119 Controlling the Device Orientation
120 Rendering Alternative Landscape Content – 1
121 Finishing Landscape Mode
122 Showing Different Content Based on Device Orientation
123 Respecting the Softkeyboard Insets
124 Using the Device Size in Conditions
125 Managing the MediaQuery Object
126 Checking the Device Platform
127 Using Cupertino (iOS) Widgets
128 Using the SafeArea
129 More Cupertino Styles
130 Using Cupertino Buttons
131 Creating Custom Adaptive Widgets
132 Wrap Up
133 Useful Resources & Links

Widget & Flutter Internals – Deep Dive
134 Module Introduction
135 The Problem At Hand
136 Widget Tree & Element Tree – What, Why and How?
137 How Flutter Rebuilds & Repaints the Screen
138 How Flutter Executes build()
139 Using “const” Widgets & Constructors
140 Writing Good Code
141 Extracting Widgets
142 Using Builder Methods
143 Understanding the Widget Lifecycle
144 Calling super.initState() etc.
145 Understanding the App Lifecycle
146 Understanding Context
147 A Problem with Lists & Stateful Widgets
148 Understanding the Problem Root
149 Using Keys
150 Wrap Up
151 Useful Resources & Links

Navigation & Multiple Screens [MEALS APP]
152 Module Introduction
153 Planning the App
154 Starting With The App – Adding Base Data
155 Creating a Grid & Working with Linear Gradients
156 Registering a Screen as the Main Screen
157 Styling & Theming
158 Navigating to a New Page
159 Passing Data via the Constructor
160 Using Named Routes & Passing Data With Named Routes
161 Diving Deeper into Named Routes
162 Adding a Meal Model & Data
163 Selecting Meals for a Chosen Category
164 Displaying Recipe Items & Using Network Images
165 Finishing the Meal List Item
166 Navigating to the Meal Detail Page
167 onGenerateRoute & onUnknownRoute
168 Finishing the Meal Detail Page
169 Adding a TabBar to the Appbar
170 Adding a Bottom TabBar
171 Adding a Custom Drawer
172 Adding Links to the Drawer
173 Replacing Pages (Instead of Pushing)
174 Popping Pages & Passing Data Back
175 Adding Filter Switches
176 Adding Filtering Logic
177 Adding a “Mark as Favorite” Feature
178 A Problem!
179 Wrap Up
180 Useful Resources & Links

State Management [SHOP APP]
181 Module Introduction
182 Planning the App
183 Defining a Data Model
184 Working on the “Products” Grid & Item Widgets
185 Styling & Theming the App
186 Adding Navigation to the App
187 Why State Management? And what is “State” and “State Management”?
188 Understanding the “Provider” Package & Approach
189 Working with Providers & Listeners
190 [DART DEEP DIVE] Inheritance (“extends”) vs Mixins (“with”)
191 Providing non-Objects
192 Listening in Different Places & Ways
193 Using Nested Models & Providers
194 Exploring Alternative Provider Syntaxes
195 Using “Consumer” instead of “Provider.of”
196 Local State vs App-wide State
197 Adding Shopping Cart Data
198 Working with Multiple Providers
199 Connecting the Cart Provider
200 Working on the Shopping Cart & Displaying a Total
201 Displaying a List of Cart Items
202 Making Cart Items Dismissible
203 Adding Product Detail Data
204 Providing an Orders Object
205 Adding Orders
206 Adding an Orders Screen
207 Using a Side Drawer
208 Making Orders Expandable & Stateful Widgets vs Providers
209 Wrap Up
210 Useful Resources & Links

Working with User Input & Forms [SHOP APP]
211 Module Introduction
212 Snackbars & Undoing “Add to Cart” Actoins
213 Showing Alert Dialogs
214 Adding a “Manage Products” Page
215 “Edit Product” Screen & A Problem
216 Using Forms & Working with Form Inputs
217 ListView or Column
218 Managing Form Input Focus
219 Multiline Inputs & Disposing Objects
220 Image Input & Image Preview
221 Submitting Forms
222 Validating User Input
223 Adding Validation to All Inputs
224 [OPTIONAL] Working with Regular Expressions
225 Saving New Products
226 Time to Update Products!
227 Allowing Users to Delete Products
228 Wrap Up
229 Useful Resources & Links

Sending Http Requests [SHOP APP]
230 Module Introduction
231 On-Device vs Web Storage
232 How to Connect Flutter to a Database
233 Preparing Our Backend
234 How To Send Http Requests
235 Sending POST Requests
236 Working with Futures in Dart
237 [DART DEEP DIVE] Futures & Async Code
238 Showing a Loading Indicator
239 Handling Errors Gracefully
240 Working with “async” & “await”
241 Fetching Data, initState & “of(context)”
242 How to Transform Fetched Data
243 Implementing Pull-to-Refresh
244 Updating Data via PATCH Requests
245 Utilizing Optimistic Updating
246 Creating Custom Exceptions & More Error Handling
247 A Challenge For You!
248 Updating the “Favorite” Status Optimistically
249 Storing Orders in the Web
250 Fetching Orders & Fixing an Issue
251 Using the “FutureBuilder” Widget & Improving the Code
252 Wrap Up
253 Useful Resources & Links

Adding User Authentication [SHOP APP]
254 Module Introduction
255 How Authentication Works
256 Prepare Backend
257 Adding the Auth Screen
258 Adding User Signup
259 Allowing Users to Log In
260 Handling Authentication Errors
261 Managing the Auth Token Locally (in the App)
262 Using the “ProxyProvider” and Attaching the Token to Outgoing Http Requests
263 Adding the Token to All Requests
264 Connecting the “Favorite” Status to Users
265 Attaching Products to Users & Filtering By Creator
266 Attaching Orders to Users
267 Adding a Logout Functionality
268 Automatically Logging Users Out (After Some Time)
269 Automatically Logging Users In
270 Wrap Up
271 Useful Resources & Links

Adding Animations [SHOP APP]
272 Module Introduction
273 Animations From Scratch (Completely Manually Controlled)
274 Using the “AnimatedBuilder” Widget
275 Working with the “AnimatedContainer”
276 More Built-in Animation & Transition Widgets
277 Fading Loaded Images In (And Showing a Placeholder)
278 Adding a “Hero” Transition
279 Working with Slivers
280 Practice: Animating Order Boxes
281 Implementing Custom Route Transitions
282 Wrap Up
283 Useful Resources & Links

Using Native Device Features (Camera, Maps, Location, …) [GREAT PLACES APP]
284 Module Introduction
285 Planning the App
286 PlaceList & Place Provider Setup
287 Adding the “Add Place” Screen & An Image Input
288 Using Image Picker & The Device Camera
289 Storing the Image on the Filesystem (on the Device)
290 Managing Data & Images via the Provider Package
291 Handling Errors
292 Testing on Real Devices
293 Preparing SQLite
294 Storing & Fetching Data with SQLite
295 Adding a Location Input & The “location” Package
296 Fetching the User Coordinates
297 Displaying a Static Map Snapshot
298 Rendering a Dynamic Map (via Google Maps)
299 Allowing Users to Pick a Location on the Map
300 Storing the Location in SQLite
301 Adding a “Place Detail” Screen & Opening the Map in “readonly” Mode
302 Wrap Up
303 Useful Resources & Links

Running Native Swift, ObjectiveC, Java or Kotlin Code
304 Module Introduction
305 Sending a Method Call from Flutter
306 Running Android Code
307 Running iOS Code
308 Wrap Up
309 Useful Resources & Links

Publishing to the App Stores
310 Module Introduction
311 Preparing the Code
312 Preparing the App Configuration
313 Preparing Third-Party Services
314 Adding Icons & Splash Screens
315 Publishing Android Apps
316 Publishing iOS Apps
317 Useful Resources & Links

Roundup & Next Steps
318 You did it!
319 Your Next Steps (To Become an Awesome Developer!)
320 How to Plan & Develop Successful Apps

Updated Course
321 What Changed? What’s New? Why did I Update the Course?
322 Changes you should not miss
323 The [LEGACY] Sections

[LEGACY] Diving Into the Basics & Understanding Widgets
324 What does [LEGACY] mean?
325 Module Introduction
326 Creating a New Flutter Project
327 Exploring the Default Project Structure
328 Diving Into the “main.dart” File
329 Widgets in Flutter – Theory
330 Creating a Widget
331 Understanding Classes & Constructors
332 Adding the “Build” Method
333 Adding the Scaffold
334 Diving Deeper Into the Syntax
335 Adding Cards & Images
336 Diving Into the Official Docs
337 Adding a Button
338 Creating a Stateful Widget
339 Managing Data Inside Stateful Widgets
340 Adding the Stateful Widget & Lists
341 Splitting our Code Up
342 Creating the “Product Manager” Widget
343 Passing Data to Stateful Widgets
344 initState() and super.initState()
345 Understanding Lifecycle Hooks
346 Diving Into Google’s Material Design
347 Understanding Additional Dart Features
348 Passing Data Up
349 Understanding “const” & “final”
350 Dart Types, Syntax & Core Features
351 Wrap Up
352 Useful Resources & Links

[LEGACY] Debugging Flutter Apps
353 Module Introduction
354 Fixing Syntax Errors
355 Understanding Runtime Errors & Runtime Messages
356 Dealing with Logical Errors
357 Using Breakpoints
358 Debugging the User Interface
359 More About Visual Helpers
360 Wrap Up
361 Useful Resources & Links

[LEGACY] Running the App on Different Devices
362 Testing Devices
363 How to Start the App
364 Testing a Real Android Device
365 Using the iOS Emulator & a Real Device
366 Running the App – Detailed Instructions
367 Using the Native IDE Consoles

[LEGACY] Working with Lists & Conditionals
368 Module Introduction
369 Creating Scrollable Lists with “ListView”
370 Optimizing the List Loading Behaviour
371 Rendering Content Conditionally
372 Alternative Approaches to Render Content Conditionally
373 One Important Gotcha
374 Wrap Up
375 Useful Resources & Links

[LEGACY] Navigation
376 Module Introduction
377 Adding Multiple Pages to our App
378 Adding Buttons
379 Implementing a Basic Navigation
380 Improving the Look of the Product Page
381 Passing Data Around (“Pushing” the Page)
382 Passing Information Back (“Popping” the Page)
383 Adding Reactions Upon Button Pressing
384 Adding the Basic Authentication Page & Replacing Routes
385 Adding the Sidedrawer & the Hamburger Icon
386 Understanding Stack Based Navigation
387 Adding Tabs
388 Finishing the Tab Navigation
389 Adding Named Routes
390 Parsing Route Data Manually
391 Lifting State Up
392 Using the Named Routes
393 Working with “onUnknownRoute” as Fallback
394 Adding Alert Dialogs
395 Showing a Modal
396 Wrap Up
397 Useful Resources & Links

[LEGACY] Handling User Input
398 Module Introduction
399 Saving User Input
400 Configuring Text Fields
401 Styling Text Fields
402 Fixing a Bug & Adding a Button
403 Using our Form to Create a New Product
404 Improving the Style of our Form
405 Fixing a Tiny “Error”
406 Adding a Switch
407 Wrap Up
408 Useful Resources & Links

[LEGACY] Diving Deeper Into Widgets
409 Module Introduction
410 Exploring the Widget Catalogue
411 There’s More Than One Widget For The Job
412 The Most Important Widgets
413 Working with Text & Fonts
414 Working with Rows
415 Decorating Boxes & Styling a Price Tag
416 Setting Borders
417 Understanding “Expanded” & “Flexible”
418 Adding a Background Image
419 Centering Input Fields
420 Adding Icons to our Sidemenu
421 Adding Icon Buttons
422 Outsourcing Code into Separate Widgets
423 Refactoring our Code
424 Creating a Standardized Tile Widget
425 Adding Separate Methods for Specific Widgets
426 Optimizing our Project
427 Responsive Design Problems
428 Adding Media Queries
429 Understanding Media Queries with ListView
430 Working with Themes
431 Listening to Touch Events with the Gesture Detector
432 Wrap Up
433 Useful Resources & Links

[LEGACY] Working with Forms
434 Module Introduction
435 Using the Form Widget
436 Adding Form Validation
437 Advanced Validation
438 A Note on the “Price” Input and the Usage of Commas/ Dots
439 Closing the Keyboard
440 Submitting Data
441 Outputting Lists of Products
442 Re-Using the Product Create Form
443 Setting Initial Values
444 Updating Products
445 Ensuring Input Visibility
446 Wrap Up
447 Useful Resources & Links

[LEGACY] Improving the App
448 Module Introduction
449 Improving the List Tile
450 Adding the Dismissible Widget
451 Deleting Products Upon Swipe
452 Restructuring the Code & Wrap Up
453 Useful Resources & Links

[LEGACY] Models & State Management
454 Module Introduction
455 What can be Improved?
456 Adding a Product Model
457 Creating a Scoped Model
458 Connecting the Scoped Model
459 Providing the Scoped Model
460 Viewing Single Products
461 Editing & Deleting Products with the Scoped Model
462 Finishing the Product Model
463 A Note on Immutability
464 Creating the Toggle Favorite Method
465 Working on the Favorite Feature
466 Adding “notifylisteners”
467 Finishing the Favorite Feature
468 Fixing a Bug related to the “Favoriting” Feature
469 Adding a User Model
470 MUST READ: Mixins & The Latest version of Dart
471 Using Mixins to Merge Models
472 Logging in with the Main & the User Model
473 Connecting Models & Sharing Data
474 MUST READ: Changing Mixins Syntax
475 Improving the Code & Fixing an Error
476 MUST READ: Unselecting the Product after Editing
477 Wrap Up
478 Useful Resources & Links

[LEGACY] Flutter & HTTP
479 Module Introduction
480 Understanding the Backend Setup
481 Sending a POST Request
482 Using the Response
483 Getting Data From a Server
484 Transforming & Extracting Response Data
485 Displaying a Loading Spinner
486 Finishing the Loading Spinner
487 Updating Products
488 Deleting Products
489 Using Pull to Refresh
490 Adding “fadein” to the Image Placeholder
491 Adjusting the Scoped Model & the Selected Product
492 Fixing the Product Selection
493 Handling Error Responses
494 Generic Error Handling
495 Adding “async” “await”
496 Improving our Code
497 Wrap Up
498 Useful Resources & Links

[LEGACY] Authentication
499 Module Introduction
500 How Authentication Works
501 Adding a “Confirm Password” Textfield
502 Implementing the Signup Functionality
503 Handling Errors
504 Adding a Spinner Whilst Signing Up
505 Adding the Signin Functionality
506 Refactoring our Code
507 Authenticating Requests with Tokens
508 Storing the Token on the Device
509 Signing Users In Automatically
510 Adding a Logout Button
511 Adding Autologout
512 Route Protection & Redirection
513 Fixing the Manual Logout
514 Time for a Quick Recap Regarding our Code Structure
515 Adding Optimistic Updating to Store the Favorite Status
516 Fetching the Favorite Status
517 Allow Editing for own Posts Only
518 Wrap Up
519 Useful Resources & Links

[LEGACY] Adding Google Maps to our App
520 Module Introduction
521 Using MapView with the latest Flutter Version
522 Unlocking the Required APIs
523 Requesting Permissions
524 Preparing our Text Form Field
525 Adding a Static Dummy Map
526 Sending a Request to Convert an Address to Coordinates
527 Adding Geocoding & Maps with Real Coordinates
528 Working on the Map Control
529 Storing Location Data in the Database
530 Fixing a Bug
531 Loading Location Data from the Backend
532 Updating an Existing Product’s Position
533 Adding the Update Method for the Location
534 Adding the Location Package
535 Using the Location Package with Version >=1.4
536 Getting the User Location
537 Preventing Memory Leaks
538 Displaying the Address
539 Showing a Fullscreen Map
540 Wrap Up
541 Useful Resources & Links

[LEGACY] Accessing the Device Camera
542 Module Introduction
543 Adding an Image Picker Button
544 Adding the “Use Camera” & “Gallery” Buttons
545 Connecting the “Choose” Buttons to the Image Picker
546 Adding an Image Preview
547 Adding Text Editing Controllers
548 Setting Up Firebase Cloud Functions
549 Adjusting Firebase Functions (Fixing an Error)
550 Adding Server Side Code
551 Reading Incoming Files & Fields
552 Storing Data and Move it to a Temporary Storage
553 Deploying our Firebase Cloud Function
554 Configuring the Upload Request
555 Setting Headers to Add the Token
556 Fixing an Error
557 Fetching & Using Images
558 Previewing & Editing the Image
559 Adding the Image Upload Flow
560 Deleting Images When Deleting a Product
561 Wrap Up
562 Useful Resources & Links

[LEGACY] Adding Animations to our Project
563 Module Introduction
564 Adding Floating Action Buttons (FABs)
565 Adding Functionality to our Favorite Button
566 Working on the Contact Button
567 Animating the Contact Icon
568 Animating the Favorite Icon
569 Animating the Options Button
570 Fading the Password Field In & Out
571 Sliding the Password Field In & Out
572 Adding Hero Widgets
573 Adding the Sliver Effect
574 Adding Route Transitions
575 Wrap Up
576 Useful Resources & Links

[LEGACY] Polishing & Bugfixing
577 Module Introduction
578 Fixing an Autologout Bug
579 Fixing the Price Input in Landscape Mode
580 Fixing the Filtered Product Index
581 Fixing the Product Title Style & the Favorite Product Selection
582 Toggling the Favorite Status
583 Clearing All Products Before Fetching
584 Testing the iPhone & Fixing the Product Reset Logic
585 Adding Space on the Product Card
586 Using Flutter Analyze
587 Possible Code Restructurings
588 Managing Global Values
589 Testing the App on an Android Device
590 Testing the App on an iPhone & Fixing the European Decimal Comma
591 Useful Resources & Links

[LEGACY] Running Platform Specific Code
592 Module Introduction
593 Understanding Material Design & Cupertino
594 Detecting the Platform
595 Using Platform Specific Widgets
596 Adding a Platform Specific Theme
597 When Should we Use Platform Specific Themes?
598 iOS Support since Flutter 0.8.2
599 Wrap Up
600 Useful Resources & Links