Flutter Trainer

What Flutter is and what makes it structurally different from platform-bridging frameworks. The engine, foundation library and widget layer; the widget, element and render trees and how they relate; the rendering pipeline; and an honest account of Flutter's advantages, disadvantages and the cases where native development is still the right call.

Topics: What Flutter is and what makes it unique · Features, advantages and genuine disadvantages · A short history and the current release train · Architecture: engine, foundation library, widgets · Widget tree, element tree and render tree · How rendering works, and what a frame costs · Platform channels and the boundary with native code · Flutter compared with React Native, Kotlin Multiplatform and native · Prerequisites, audience and the problems Flutter solves

• Assignments: (1) Explain what happens between a setState call and a repainted pixel; (2) Assess one existing application and argue for or against a Flutter rewrite
• Capstone: Produce an architecture note choosing Flutter or native for a specific product, with reasoning

Getting to a running application on a real device. Installing the Flutter SDK and platform toolchains on Windows, macOS and Linux, Git and IDE setup, flutter doctor and the errors it reports, project structure, the pubspec, and the development loop that hot reload makes possible.

Topics: System requirements and installing the Flutter SDK · Installing Git and the platform toolchains · Android Studio, IntelliJ IDEA and Visual Studio Code setup · flutter doctor and resolving what it reports · Creating a project and reading its structure · pubspec.yaml, dependencies and assets · Emulators, simulators and physical devices · Hot reload vs hot restart, and when each is not enough · DevTools: inspector, performance and logging · Codemagic and other build services

• Assignments: (1) Set up a working toolchain and run an application on both an emulator and a real device; (2) Add a package and an asset to a project and use both
• Capstone: Build the development environment and starter project you keep for the rest of the course

The language, taught as Flutter actually uses it. Types, variables and functions; control flow; classes, constructors and object orientation; final and const and why const matters for rebuild cost; null safety; collections and the functional methods used constantly in widget code; then futures, async/await and streams.

Topics: Data types, variables and type inference · Functions, named and optional parameters, arrow syntax · Operators, decision making and loops · break, continue and comments · final and const, and const constructors in widget trees · Classes, constructors, factories and inheritance · Mixins, abstract classes and interfaces · Null safety, late, and the null-aware operators · Collections: lists, sets, maps, spread and collection-if · map, where, reduce and the iterable methods · Futures, async/await and error handling · Streams, StreamController and async generators · Generics and typedefs

• Assignments: (1) Refactor a procedural Dart script into classes with null safety enforced; (2) Consume an asynchronous data source with futures and again with streams
• Capstone: Write a Dart data layer with models, serialisation and asynchronous access, tested without any UI

The idea the whole framework rests on. Stateless and stateful widgets, the build method, the widget lifecycle, keys and why they matter when lists reorder, and the core display widgets: Scaffold, AppBar, Container, Text, RichText, Image, Card and Icon.

Topics: Types of widget: stateless, stateful, inherited · The build method and when it is called · The State lifecycle: initState, didUpdateWidget, dispose · Keys, and what breaks without them · MaterialApp, Scaffold and AppBar · Container: why it exists and every property that matters · Text and RichText styling · Images: assets, network, fade-in and caching · Card, Icon and Divider · Material Design and Cupertino widget families

• Assignments: (1) Convert a stateless screen to stateful and manage its lifecycle correctly; (2) Reproduce a supplied design using only core display widgets
• Capstone: Build a complete static screen from a design specification, pixel-accurate on two screen sizes

The subject that causes most early frustration, taught through the rule that explains it: constraints go down, sizes go up, the parent sets position. Single-child and multi-child layout widgets, Row and Column with their alignment and sizing axes, Stack and positioning, Expanded and Flexible, and the overflow errors and how to read them.

Topics: How to lay out a widget: the constraint model · Single-child layout widgets: Center, Padding, Align, SizedBox · Row and Column: main axis, cross axis, alignment and sizing · Expanded, Flexible and Spacer · Stack, Positioned and IndexedStack · Wrap, and layouts that flow · Table and DataTable · Building complex nested layouts · Responsive layout: MediaQuery, LayoutBuilder, breakpoints · SafeArea, orientation and device differences · Reading and fixing overflow errors

• Assignments: (1) Rebuild three real application screens from screenshots; (2) Fix five deliberately broken layouts, explaining the constraint failure in each
• Capstone: Build a responsive screen that works correctly on phone, tablet and desktop widths from one widget tree

Making the interface respond. Pointers and the gesture system, buttons and their variants, the input widgets, then forms in full: FormField, controllers, validators, focus handling, submission and the error presentation that decides whether a form is usable.

Topics: Pointers, hit testing and the gesture arena · GestureDetector and InkWell · Button types and their theming · TextField: retrieving values, controllers, obscuring, expanding, sizing · Checkbox, Radio, Switch and Slider · Range and image sliders · Creating a Form and using FormField · Validation, validators and error text · Focus nodes and keyboard navigation · AlertDialog: basic, confirmation, text field and option variants · SnackBar, Toast and Tooltip feedback · Progress indicators, linear and circular

• Assignments: (1) Build a multi-field registration form with validation and submission handling; (2) Add gesture handling to a custom widget with correct hit testing
• Capstone: Deliver a complete input flow with validation, feedback, loading state and error recovery

Presenting collections without destroying performance. Basic lists versus builders, long and infinite lists, horizontal lists, grids by count, builder and extent, then slivers — CustomScrollView, SliverAppBar, SliverList and SliverGrid — which are how any non-trivial scrolling effect is actually built.

Topics: Basic lists and ListTile · ListView.builder and working with long lists · Horizontal lists and scroll direction · Separated lists and dividers · GridView.count, GridView.builder and GridView.extent · Pull to refresh and infinite scroll · How to use slivers, and what CustomScrollView is · SliverAppBar and its properties · SliverList, SliverGrid, SliverFixedExtentList and SliverToBoxAdapter · ScrollController and scroll position · List performance: keys, item extent and rebuild cost

• Assignments: (1) Convert a non-performant list to a builder and measure the difference in DevTools; (2) Build a collapsing header with SliverAppBar over a mixed sliver body
• Capstone: Build an infinite, filterable, pull-to-refresh feed with a collapsing header that stays at 60 frames per second

Moving between screens and passing data. The Navigator stack with push and pop, returning results, named routes and route generation, arguments, nested navigators for tab and drawer shells, then deep links and the declarative Router API for applications that need URL-addressable state.

Topics: Creating routes and the Navigator stack · Navigator.push and Navigator.pop · Returning a result from a screen · Named routes and onGenerateRoute · Passing and validating route arguments · TabBar, TabBarView and DrawerNavigation · Drawer: adding it to Scaffold, populating and closing it · BottomNavigationBar and its properties · Nested navigators and per-tab stacks · Page transitions and Hero animations between routes · Deep links, URL strategy and the Router API · Route guards and authentication-aware navigation

• Assignments: (1) Build a tabbed shell where each tab keeps its own navigation stack; (2) Implement a deep link that opens a detail screen directly with arguments
• Capstone: Build a multi-screen application with named routes, guards, arguments and working deep links

The decision that determines whether an application stays maintainable. Ephemeral state versus application state, setState and its limits, lifting state up, InheritedWidget as the mechanism everything else is built on, then Provider, Riverpod and BLoC compared on real criteria — testability, boilerplate, team size and rebuild control.

Topics: What state is: ephemeral state vs app state · setState and where it stops scaling · Lifting state up and prop drilling · InheritedWidget and InheritedNotifier · ChangeNotifier and Provider · Consumer, Selector and controlling rebuild scope · Riverpod: providers, scopes and testability · BLoC and Cubit: events, states and streams · Repository pattern and separating data from presentation · Dependency injection approaches · Choosing an approach for a stated application size and team · Testing state in isolation

• Assignments: (1) Implement the same feature three ways — setState, Provider and BLoC — and compare; (2) Fix an application that rebuilds its whole tree on every change
• Capstone: Refactor a prop-drilled application onto a single state management approach with a written justification

Making it look right and move well. ThemeData, extending a parent theme and dark mode; implicit and explicit animation; AnimationController, Tween, curves, physics-based and Hero animations; then graphic manipulation with opacity, transforms, decoration and CustomPainter for anything the widget library does not provide.

Topics: Creating a ThemeData and extending the parent theme · Using a theme, and theme extensions · Dark mode and adaptive theming · Implicit animations: AnimatedContainer, AnimatedOpacity and friends · Explicit animation: AnimationController, Tween and curves · Physics-based animation · Hero animations across routes · Staggered and chained animations · Opacity, RotatedBox, Transform and BoxDecoration · CustomPainter and the Canvas API · ClipPath, shaders and gradients · Charts: line, bar and pie approaches in Flutter · Splash screens and their characteristics

• Assignments: (1) Theme an application for light and dark mode from a single source of truth; (2) Build one custom-painted widget the standard library cannot express
• Capstone: Deliver a themed application with a signature animated interaction that holds its frame budget

Connecting the application to real data. HTTP clients, JSON serialisation and model classes, loading and error states done properly, then local persistence with SQLite and shared preferences, and Firebase for authentication, storage and real-time data — including the update-versus-set distinction that trips up most first implementations.

Topics: Accessing a REST API with http and dio · JSON serialisation: manual and code-generated · Modelling responses and handling errors · FutureBuilder, StreamBuilder and loading states · Caching, retry and offline behaviour · SQLite database concepts and the sqflite package · shared_preferences and secure storage · Firebase introduction and project setup · Firebase authentication: anonymous, email and Google sign-in · Firebase Cloud Storage for files · Realtime Database and Firestore · Firebase set vs update, and querying by range

• Assignments: (1) Consume a paginated REST API with correct loading, empty and error states; (2) Persist and query data locally with SQLite, surviving an application restart
• Capstone: Build an application backed by a real API with offline caching and authenticated access

The last mile, which is where most courses stop and most projects struggle. Device integration for camera, contacts, permissions, URLs and maps; writing platform-specific native code; creating and publishing packages and plugins; the three levels of testing; and producing signed, sized, store-ready builds with a repeatable pipeline.

Topics: URL launcher, permissions, contacts and camera · Google Maps: appearance, markers and polylines · Writing Android-specific and iOS-specific code · Platform channels and method channels · Types of package, and developing a package or plugin · Publishing a package to pub.dev · Unit testing Dart logic · Widget testing: pumping, finders and matchers · Integration testing with flutter_driver and integration_test · Golden tests for visual regression · Performance profiling: jank, rebuild counts and the DevTools timeline · App size, tree shaking and deferred loading · Build flavours and environment configuration · Signing and releasing to the Play Store and App Store · CI/CD for Flutter builds

• Assignments: (1) Write unit, widget and integration tests covering one complete feature; (2) Produce signed release builds for Android and iOS with separate dev and prod flavours
• Capstone: Ship a complete application: native integration, tested, profiled, flavoured, signed and built by a pipeline