Dart and Flutter: The Complete Developer’s Guide

Dart and Flutter: The Complete Developer’s Guide
Dart and Flutter: The Complete Developer’s Guide
English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 31 Hours | 9.91 GB

Everything you need to know for building mobile apps with Flutter and Dart, including RxDart and Animations!

If you’re tired of spinning your wheels learning Swift or Android, this is the course for you.

Animations? You will learn it. Architectural Patterns? Included. Navigation? Of course!

Flutter is a newcomer to the mobile development scene. Strongly supported by Google, it is already viewed as an ideal platform for replacing native Swift and Android development. Thanks to its amazing standard library of widgets, fast compile times, and amazing documentation, developers are falling in love with Flutter!

This course supports MacOS and Windows – develop Android and iOS apps easily!

Flutter apps are created using the language Dart. No problem if you’re not already familiar with Dart; this course includes a lightning fast introduction to Dart at the beginning, along with hours of bonus lectures at the end of the course solely focused on Dart and its advanced features. If you come from a background working with Java, Ruby, or Javascript, you’ll feel right at home with Dart – the syntax is nearly identical, only a few core concepts need to be learned. Dart is a strongly typed language – but don’t be discouraged if you’re not a fan of strong types! I spend special time in this course to make it extra clear why developing with a strongly typed language is a breeze!

One of the greatest challenges around developing Flutter applications right now is understanding how to design and architect apps. Flutter is still in rapid development, and the community at large is still trying to find out the best techniques. With this in mind, special attention is paid in the course to making sure you understand the primary design patterns advocated by Google’s Flutter team, including both the ‘Stateful Widget’ pattern and the ‘BLOC’ pattern. The ‘BLOC’ pattern makes heavy use of Reactive Programming techniques, which you’ll learn about in this course as well. These techniques can be easily applied to other languages and frameworks as well – talk about a bonus!

Of course, no mobile app is complete without some nice looking animations. You’ll learn how to build animations using Flutter’s standard library of tools, which can be easily used to make interactions that your users will love. You should plan to complete the course with knowledge of how to reference Flutter’s standard library of widgets to assemble complex animations.

You will:

  • Understand the Dart language and its primary features
  • Store information for long periods of time on the user’s device with offline storage
  • Learn how to optimize network requests for improved performance on mobile networks
  • Delight your users with complex animations
  • Expose the functionality of your apps with multi-screen navigation
  • Steer through the incredible amount of Flutter documentation
  • Master Reactive Programming with streams by using RxDart
  • Implement advanced design patterns advocated by Google’s official Flutter team
  • Handle user input with form validation
  • Learn to build open source Dart packages and distribute them to other developers
Table of Contents

Let s Dive In!
1 How to Get Help
2 Course Organization

A Dart Introduction
3 Dart Overview
4 Creating Classes
5 Creating Class Instances
6 Constructor Functions
7 Review on Constructors
8 Completed Code
9 The Dartpad Editor
10 Our First Program
11 Pulling the Pieces Apart
12 Functions in Dart
13 Introduction to Types
14 Why Use Types
15 String Interpolation
16 Object Oriented Programming in Dart

Staying on Target with Dart
17 App Overview
18 ToString on Cards
19 Shuffling a List
20 Annotating Argument Types
21 Filtering Lists
22 Annotating Argument Types
23 Filtering Lists
24 Shorthand Function Syntax
25 Removing Individual Records
26 RemoveCard Implementation
27 Named Parameters
28 OOP Design Flow
29 Adding Fields to Classes
30 Associated Methods
31 More Initialization with Constructors
32 For Loops
33 Adding Elements to Lists
34 More on Variable Initialization
35 Customizing Print Statements

Flutter Environment Setup – MacOS
36 Flutter Setup on MacOS
37 SDK Extraction
38 Editing the PATH Variable
39 XCode License
40 Generating Flutter Projects

MacOS Setup – Android
41 Android Setup on MacOS
42 Android Dependencies
43 Android Project Setup
44 More Android Dependencies!
45 Android Emulator Creation
46 Flutter Startup
47 Finished Android Setup

MacOS Setup – iOS
48 iOS on Mac Setup
49 XCode Setup(1)
50 XCode Setup
51 iOS Simulator Startup
52 App Startup

Flutter Setup on PC
53 Flutter Install
54 More Flutter Installation
55 Android Install
56 Additional Dependencies
57 Generating a Project
58 Selecting an Image
59 Starting the Emulator
60 Finishing Android Setup

App Building Time!
61 Code Editor Setup
62 Named Parameter Clarification
63 Required Parameters
64 Child Parameters
65 Displaying Icons
66 Adding Custom Widgets
67 What s Flutter About, Anyways
68 App Overview
69 The Four Step Design Process
70 Import Statements
71 Creating Widgets
72 Displaying Content on Screen
73 Showing a Scaffold
74 Customizing the App Bar

State Design with Flutter Apps
75 Stateless vs Stateful Widgets
76 The Build Method
77 Local Import Statements
78 Quick Breather and Review
79 Refactoring Stateless to Stateful
80 More Refactoring to Stateful Widgets

High-Level Dart
81 Generics in Dart
82 Why Two Classes

HTTP Requests with Flutter
83 Photos API
84 Parsing Future Responses into a Model
85 Updating the AppState Widget
86 Building Lists of Widgets
87 Sending Images to the ImageList
88 The Final Keyword
89 Building Lists with ListView
90 Listing URL s
91 Text to Images
92 Containers for Positioning
93 Adding Border Style
94 Working with JSON
95 Column Widgets for Layout
96 Selective Padding
97 App Review
98 Casting JSON to Model Instances
99 Named Constructors
100 Adding an Image Model
101 Function References
102 The HTTP Package
103 Issuing HTTP Requests
104 Handling Dart Futures

Forms and Validation with Flutter
105 App Overview
106 Layout Control
107 Form Validation
108 Referencing Widgets with Global Keys
109 The Form Widget and FormState
110 Creating a Global Key
111 Referencing FormState with Global Keys
112 Validating via FormState
113 Triggering Validation
114 Retrieving Form Values
115 Final Form Submittal
116 Boilerplate App Code
117 Code Reuse with Mixins
118 Mixin Validator Implementation
119 Creating the Login Screen
120 More Container Styling
121 Labels and Hint Text
122 Customizing Keyboard Type
123 Handling Password Inputs
124 Displaying Buttons with RaisedButton
125 Changing Widget Colors

Reactive Programming with Dart
126 A Quick Detour
127 Why Streams
128 Word Guessing
129 Stream s Take and Where Functions
130 Validation with Streams
131 Email Validation
132 Wiring up the Error
133 Streams by Analogy
134 Characteristics of Streams
135 StreamControllers and Sinks
136 Mapping a Stream
137 Adding a StreamTransformer
138 Implementing the Listener
139 Stream Review
140 Let s Build a Game

Advanced Flutter Architecture – The Bloc Pattern
141 Bloc s Vs Stateful Widgets
142 Issues With Bloc Access-3
143 Shortcut Access With Getters-5
144 Public Vs Private Fields-7
145 Improving The Bloc Api-9
146 Validation Transformers-11
147 A Technicality Around Mixins-13
148 Cleaning Up Controllers-15
149 Bloc Application-17
150 The Purpose Of Streams With Blocs-19
151 Generating A New Project-21
152 App Boilerplate-23
153 Second Time On Loginscreen-25
154 Textfields With Raisedbuttons-27
155 How To Use Textfields-29
156 Bloc Design For Textfields-31
157 Annotating Stream Types-33

Consuming BLOC Data
158 The Streambuilder Widget
159 Enabling Form Submission
160 Stream Merging Possibilities
161 Streambuilder For Password Fields
162 Scoped Bloc Approach
163 Provider Implementation
164 The Provider s Of Function
165 The Provider s Constructor
166 The Provider In Action
167 Accessing The Bloc
168 Breather And Review

RxDart for Reactive Programming
169 Introducing Rxdart
170 Review Of Blocs
171 More On Rxdart
172 The Combinelatest Function
173 Combinelatest In Action
174 More On Streambuilder
175 Interpreting Stream Values
176 Broadcast Streams
177 Disabled By Default
178 Replacing Controllers With Subjects

Building Delightful Animations
179 App Overview
180 Performance Savings With Animatedbuilder
181 Nature Of Animation
182 Starting The Animation
183 Watching For Taps With Gesturedetector
184 Reversing Animation States
185 Building The Box
186 Layouts With The Stack Widget
187 Order Of Drawing Widgets
188 Add Center Widget
189 Positioned Widgets
190 Animation Library Classes
191 Expanding Stack Dimensions
192 Three Reasons For Strange Layouts
193 Positioned Constraints
194 Negative Offsets
195 Stack Clip Settings
196 Adjusting Tween Ranges
197 Adding Box Flaps
198 Rotating Widgets
199 Rotation By Radians
200 Changing Rotation Point
201 App Boilerplate
202 A Touch Of Positioning
203 Boxanimation Controller
204 Adding Animated Builders
205 Resetting Animations
206 Constraining Animation Range
207 Adding The Right Flap
208 Negative Rotation Values
209 Toggling Animation State
210 Animation Wrapup
211 Statefulwidgets For Animations
212 Widget Structure
213 Displaying A Cat
214 The Initstate Method
215 Declaring The Tickerprovider
216 Tweens With Curves

Performant Data Fetching
217 App Overview
218 Hacker News Api
219 More Api Challenges
220 Api Performance Strategy
221 Creating The Itemmodel Class
222 A Few More Itemmodel Properties
223 Api Provider Implementation
224 Fetching Individual Items

Testing with Flutter and Dart
225 Testing With Dart
226 A Few Imports
227 Writing Expectations
228 Mocking Http Requests
229 Returning Json
230 Testing Fetchitem

Offline Data Storage
231 Sqlite Db Provider
232 Turning Class Instances To Maps
233 Implementing The Repository
234 More On The Repository
235 Type Annotations
236 Casting Lists
237 Database Imports
238 Async Constructors
239 Creating A Db Connection
240 Creating Tables With Sqlite
241 Adding Table Columns
242 Issuing Queries
243 Multiple Named Constructors
244 Massaging Db Return Maps

Type Design
245 More On The Repository
246 Quick Gotcha
247 Another Quick Gotcha!
248 Fetchtopids Implementation
249 Abstract Classes
250 The Need For Abstract Classes
251 Why Abstract Classes
252 More On Abstract Classes
253 Repository Interface Design
254 Defining The Source
255 Lists Of Sources And Caches
256 Ultimate Reusability

On Demand Widget Rendering
257 App Setup
258 Bloc Testing
259 Type Annotations Solve Problems
260 Circular Progress Indicator
261 Item Fetching Architecture
262 Giant Gotcha With Streambuilder
263 Giant Gotcha Solution
264 Implementing Scanstreamtransformer
265 Finishing The Scanstreamtransformer
266 Adding The Items Controller
267 A Gotcha Around Streams Impossible!
268 A Touch Of Boilerplate
269 Single Transformer Application
270 The Listview Tile
271 Streambuilder Setup
272 Wrapping Up The Futurebuilder
273 Double Gotcha!
274 Stream Subscriptions
275 Stream Subscription Fix
276 Additional Streams
277 A Laborious Refactor
278 Result Of Refactor
279 Data Fetching Concerns
280 Quick Debug Session
281 Resolving Database Conflicts
282 Building Story Tiles
283 Comments Icon
284 Applying Dividers With Height
285 Loading Container Stand-In
286 Building The Loading Container
287 Showing The Loading Container
288 Long-Lived Cache Values
289 Swipe To Refresh Indicator
290 Solution Outline
291 Implementing A Refresh Widget
292 Clearing Database Tables
293 Communicating A Future To Onrefresh
294 Futurebuilder In Action
295 The Stories Provider
296 Bloc Design
297 Exposing Bloc Getters
298 Wiring Up The Stories Provider

Navigation with Flutter
299 Navigation In Flutter
300 Comments Bloc Design
301 More On Comments Bloc
302 Recursive Data Fetching
303 Quick Fix
304 Connecting The Comments Provider
305 Testing Recursive Fetching
306 Consuming The Item Map
307 Displaying The Story Title
308 Text Styling
309 Container Alignment
310 Map Based Routing
311 Building The Comments List
312 More Logic Extraction
313 The Comment Widget
314 Comment s Futurebuilder
315 Showing Individual Comments
316 Recursive Rendering
317 Styling The Comment List
318 Defaulting Null Values
319 Handling Deleted Comments
320 Nested Comments
321 Ongenerateroute-Based Navigation
322 Listtile s Contentpadding Property
323 Replacing Placeholder Characters
324 Loading Containers For Comments
325 App Wrapup
326 Last Fix!
327 Ongenerateroute Implementation
328 Navigating In Style!
329 A Pageroute For Newsdetail
330 A Scaffold In Newsdetail
331 Parsing Route Settings
332 The Comments Bloc Provider

Appendix One Building Open Source with Dart
333 Dart Local Installation
334 Terminal Design
335 Terminal Implementation
336 Stdout And Stdin
337 Import Statements
338 Stdout Instance
339 More On Import Statements
340 Testing The Import Class
341 Checking Operating System
342 Clearing Windows Terminal
343 Clearing Other Terminals
344 Dart Install On Mac
345 Testing Clearscreen
346 Collecting Input Over Stdin
347 Option Class Fields
348 Adding Dynamic Fields
349 Printing Individual Options
350 Testing Option Printing
351 List Shortcomings
352 Maps In Dart
353 Refactor To Maps
354 The Prompter Class
355 Editor Setup For Dart
356 Testing The Prompter
357 Extracting The Terminal
358 Var Vs Final For Variables
359 Final s Affect On Values
360 Const s Dual Nature
361 Const s Behavior By Type
362 Marking Terminal As Const
363 Private Variables
364 Finishing Prompter
365 Error Handling
366 App Overview
367 Asking Binary Questions
368 Testing Binary Inputs
369 Code Similarities
370 Refactor For Code Reuse
371 More On Private
372 Central Lib File
373 A Single Export Point
374 A Relevant Example File
375 Outstanding Project Config
376 Uploading The Prompter Lib
377 Folder And File Structure
378 The Pubspec File
379 Running Dart Files
380 Program Design Methodology
381 Class Creation

Appendix Two Building a Dart CLI
382 App Overview
383 Building Options From Images
384 Testing Image Selection
385 Converting Images
386 The Convertimage Function
387 Reading File Contents
388 Encoding To Jpg Or Png
389 Writing Files To The Hard Drive
390 Returning The Image Name
391 Testing Image Conversion
392 Opening The Image
393 Project Setup
394 Importing Library Code
395 Forcibly Exiting A Program
396 Prompting For File Type
397 Implementation Flow
398 Working With The Current Directory
399 Filtering Non-Files
400 Filtering Non-Images

Download from Rapidgator

Download from Turbobit