Skip to content
academia.sh
tr
Log in

Course Intermediate

Flutter

Published Updated

By the end of this course

Start course

01

Dart and the Component Model

Dart fundamentals and asynchronous Dart, the widget concept, stateless and stateful widgets, the three-tree model, layout widgets and the constraint flow, platform widget families.

  1. 01 Dart Fundamentals A small Dart core that classifies who decides a widget's width. The lesson teaches Dart's types, null safety, and classes through that core and introduces the four sizings: forced, chosen, clamped, stretched.
  2. 02 Asynchronous Dart Two measurements of a widget whose width arrives later. The lesson explains futures, async and await, streams, the event loop, and isolates through the order in which the tree is built.
  3. 03 The Widget Concept In an interface model where everything is a widget, padding is a widget too. The lesson measures that a widget is an immutable recipe and why a card, despite the same request, meets a different owner depending on its position.
  4. 04 Stateless and Stateful Widgets A stateless widget gives its recipe once; a stateful widget carries its own state in a separate object. The lesson measures that the recipe is rebuilt when the state changes and who gives a search box its width after a relayout.
  5. 05 The Three-Tree Model The framework keeps the same interface in three separate trees: the widget tree of recipes, the living element tree, and the render object tree that does the layout. The lesson explains what each tree does and measures why the layout result belongs only to the last tree.
  6. 06 Layout Widgets Column, row, and flexible child are the layout widgets that pass the constraint down. The lesson separates tight and loose flexible children and shows by measurement that being a flexible child does not make the widget inside it stretched.
  7. 07 Platform Widget Families The framework offers separate widget sets for the design languages of two platforms. The lesson measures the difference between the families, the choice by platform, and how the same action button, although it reports a different request in each family, gets the same width in a fixed slot.

02

Application Structure

State management approaches, navigation and routing, networking and serialization, local storage, assets and fonts, animations, platform channels.

  1. 01 State Management Approaches Shared state changes what a widget requests, not who determines its width. The lesson measures the width of a badge fed by a counter and shows that the badge stays chosen under the row's unbounded constraint.
  2. 02 Navigation and Routing Whichever route opens the page, the navigator determines its width. The lesson measures three routes and three deep links and shows that the request of the page does not enter the result.
  3. 03 Networking and Serialization A width request that comes from the server, the cache, or a default is clamped if it falls outside the range. The lesson decodes the request of a banner from JSON and measures that the origin does not change the sizing.
  4. 04 Local Storage A saved preference can make a card flexible, and a stale preference keeps producing the same record. The lesson reads the preference from a key-value store and measures who owns the width of the card.
  5. 05 Assets and Fonts The font scale enlarges the request of a button, and when the growing request exceeds the range the button is clamped. The lesson gives the scale as 1, 2, and 3 and measures how widening the range changes the result.
  6. 06 Animations An animation runs the layout again on every frame, but the owner of the width may not change on every frame. The lesson moves the width of a panel from 80 to 240 in five frames and measures the sizing of each frame.
  7. 07 Platform Channels However many messages arrive from the platform, the framework forces the width of the embedded view. The lesson measures this with three different requests and with repeated messages.

03

Quality and Release

Test types, developer tools, performance tuning that cuts unnecessary rebuilds, package management and version constraints, per-platform build and release.

  1. 01 Test Types A test compares the expected sizing with the measured record. The lesson measures the same screen on two test surfaces and shows what a test cannot see.
  2. 02 Developer Tools The widget inspector, layout inspection, and the performance view show a tree while it runs. The lesson matches the constraint and width the inspector shows with the measured record.
  3. 03 Performance Tuning Unnecessary rebuilds and relayouts are the most common source of performance problems. The lesson shows with a measured record how high a change climbs in the tree.
  4. 04 Package Management An app grows with packages written by others. The lesson explains the package repository, the version constraint, and the lock file; it measures how the new version of a package affects the width of a widget.
  5. 05 Build and Release After an app is written, it is built, signed, and distributed through a channel until it reaches the user. The lesson lists this path per platform, measures the same release for a phone and a tablet, and gathers the sizing of nineteen lessons in one table.

Final exam

Flutter — Final Exam

In preparation

This course's question bank is not complete yet. The exam opens here automatically once enough questions are added.

Start typing to search.

↑↓ ↵ Esc navigate · open · close