Flutter Ecosystem

setState in a controller listener re-runs the State's whole build method every frame, rebuilding widgets that never change. AnimatedBuilder or a FooTransition widget scopes the rebuild to what depends on the animation, and FadeTransition avoids widget rebuilds altogether.

Mix a ticker provider into the State, create the controller in initState with vsync: this and a duration, call repeat(reverse: true) while recording, stop or animate it back when recording ends, and dispose it in dispose before super.dispose().

The app's HeroController pairs Hero widgets with equal tags on the outgoing and incoming PageRoutes. During the route transition, the destination hero's child flies in the Navigator's overlay between their bounds while placeholders fill both original slots.

AnimatedContainer's State keeps its own AnimationController; when a rebuild passes a new property value it tweens from the current value to it over duration and curve. Loops, on-demand playback, gestures and shared timelines need an explicit controller.

A Tween is an Animatable that maps a 0.0-to-1.0 animation value onto a begin-to-end range of sizes, colors or offsets. tween.animate(controller) and controller.drive(tween) are the same operation written from opposite ends.

A Cubit is a bloc-package state holder: it starts from the value passed to super, changes only when its own methods call emit, exposes the current value through state and publishes each later change on a broadcast stream.

A Bloc receives event objects through add. Each event type has one handler registered with on<E> in the constructor; the handler gets the event and an Emitter and calls it zero or more times, often around an await, to produce new states.

blocTest builds a fresh bloc, subscribes to its state stream, runs act, closes the bloc and compares every state emitted after that against expect, in order. The constructor's initial state is never pushed to the stream, so it is never recorded.

BlocBuilder rebuilds part of the UI from the current state and may run its builder many times, so it must be pure. BlocListener runs a void callback once per state change, never for the initial state, so dialogs, snackbars and navigation belong there.

A Cubit is enough when state changes are direct method calls. Choose a Bloc when you need each change traced to the event that caused it, or need to transform incoming events, such as debouncing a search or dropping overlapping requests.

AsyncValue is Riverpod's sealed result type for async providers: AsyncData, AsyncLoading or AsyncError. A widget watches the provider and switches over the AsyncValue - exhaustively, with no default - or calls when(data:, error:, loading:).

An annotated function with a Ref first parameter becomes a read-only functional provider whose kind follows its return type; an annotated class extending _$Name with build() becomes a notifier provider. Names are lower camel case plus Provider, with a trailing Notifier stripped.

autoDispose destroys a provider's state once nothing listens to it any more. Leaving the product screen removes its last listener, so the state and fetched product are dropped; reopening reads the provider again, which rebuilds it and refetches.

Provider for a synchronous computed or injected value, FutureProvider for data loaded once, StreamProvider for values that keep arriving, and NotifierProvider or AsyncNotifierProvider when the UI must change the state through methods.

ref.watch returns a provider's value and subscribes, so the widget or provider rebuilds on change; ref.read returns the current value once with no subscription, for event handlers; ref.listen runs a callback on change for side effects like a snackbar.

context.watch<T>() returns the nearest provided T and rebuilds the widget when it notifies; context.read<T>() returns it without subscribing, for callbacks; context.select rebuilds only when the value its selector derives changes.

Only descendants of a provider widget can read it, and the nearest provider of the requested type wins. Place ChangeNotifierProvider at the lowest common ancestor of every widget and route that reads it, no higher than its state should live.

Provider exposes a plain value without listening; ChangeNotifierProvider listens to a ChangeNotifier and disposes it; ListenableProvider and ValueListenableProvider cover other listenables; FutureProvider and StreamProvider expose an async result, starting from a required initialData.

context.watch subscribes the widget, which is only meaningful during build: in onPressed provider's debug assertion rejects listening, and in initState Flutter rejects the dependency. Use context.read, or Provider.of with listen: false, at both call sites.

Use create when the provider builds and owns the object, .value when it exposes an instance owned elsewhere. A new object inside .value is recreated on every rebuild; an existing instance passed to create gets disposed while still in use.

Calling .obs wraps a value in an Rx type such as RxInt. Obx records every Rx whose value its builder reads while running and rebuilds when one changes; a builder that reads no observable throws GetX's 'improper use' error.

Get.put registers and starts an instance immediately; Get.lazyPut registers a builder that runs on the first Get.find. Bindings group those calls per route. onInit runs when the instance starts, onReady one frame later, onClose when it is deleted.

GetMaterialApp owns a global navigator key, so Get.to, Get.toNamed and Get.back push and pop on it from anywhere, and Get.snackbar inserts entries into that navigator's overlay. Without GetMaterialApp or Get.key, these calls throw.

GetBuilder rebuilds when the controller calls update(), optionally only builders with a given id, and works with plain fields. Obx rebuilds automatically when an Rx value read in its builder changes. GetBuilder is explicit and cheaper; Obx is less code.

GetX state lives in one global registry, so tests leak instances, Get.find hides dependencies and navigating controllers need a navigator. Call Get.reset() in tearDown, register fakes first, inject dependencies by constructor and move navigation behind an interface.

A late BehaviorSubject listener first gets the latest value (or error), a PublishSubject listener gets only later events, and a ReplaySubject listener gets the buffered history, capped by maxSize. BehaviorSubject suits UI state: late listeners see the current value.

Feed TextField changes into a stream, apply debounceTime so a query fires only after typing pauses, drop repeats with distinct, then switchMap each query to the search call so a newer query unsubscribes from the older one and stale results are discarded.

switchMap cancels the running inner stream when a new event arrives, exhaustMap ignores new events until the running one completes, and flatMap runs them all concurrently, optionally capped by maxConcurrent. Search wants switchMap, a submit button exhaustMap, parallel downloads flatMap.

Core Stream already maps, filters, de-duplicates and runs async work in order (map, where, distinct, asyncMap, asyncExpand). RxDart earns its dependency for timing (debounceTime, throttleTime), cancel-or-ignore flattening (switchMap, exhaustMap, flatMap) and combining sources (combineLatest2, zip2, merge, withLatestFrom).

throttleTime defaults to leading: true and trailing: false: it emits the first event, then drops everything else for the duration. Typing "dune" quickly searches for "d" and never for "dune"; search needs debounceTime or trailing: true.

The Store holds all app state and is built from a reducer, an initialState and middleware; a reducer maps state and action to the next state. StoreProvider exposes the Store; after a dispatch the Store emits onChange and connected widgets rebuild.

The converter maps the Store to a small view model and runs on every store change. With distinct: true, StoreConnector rebuilds only when the new view model != the previous one, so the view model needs value equality.

flutter_redux needs one global store, a converter and value-equal view model per widget, dynamic actions and extra middleware for async work. Before extending a legacy app, check the package version, rebuild cost and conventions.

Middleware sees each action before the reducer: on a charge action it calls next(action), starts the payment future and later dispatches a success or failure action. A thunk middleware lets you dispatch a function that receives the store.

onInit runs in initState before the first view model is built, onWillChange runs on a change before the rebuild, onDidChange and onInitialBuild run after the frame via post-frame callbacks, and onDispose runs in dispose. Navigation belongs in onWillChange.

Run flutter create --org com.acme --platforms android,ios,web shop_app. --org sets the reverse-domain prefix of the Android application ID and iOS bundle ID; --platforms decides which platform folders are generated.

flutter devices lists connected devices with their ids, flutter emulators --launch starts an emulator or simulator, and flutter run -d <id or name prefix> runs on that device; -d all targets every device.

flutter doctor runs validators for the Flutter SDK, each host toolchain, connected devices and network access, marking each [✓] ready, [!] partial or [✗] missing with a fix hint; -v adds paths, revisions and timings.

Extract the Flutter SDK to a user-writable folder and put its bin directory on PATH, which provides both flutter and dart. Doctor warns when either is missing from PATH or resolves outside that SDK.

flutter clean deletes the project's build/ and .dart_tool/ directories, platform ephemeral folders and generated files, and cleans the Xcode workspace. It helps when stale generated state survives an SDK, plugin or config change; otherwise it only forces a slower full rebuild.

FVM keeps several Flutter SDKs in a shared cache and records each project's version in a committed .fvmrc file; fvm flutter and fvm dart then run the SDK that project pins, so the two apps never share one global Flutter.

fvm use pins a version for one project in .fvmrc; fvm global sets a machine-wide default link. fvm flutter uses the nearest project pin first, then the global version, then whatever flutter is on PATH.

.fvmrc is committed JSON holding the pinned flutter version, optional flavors and per-project switches; .fvm/ holds local links into the FVM cache. VS Code's dart.flutterSdkPath is set by FVM; Android Studio is pointed at .fvm/flutter_sdk manually.

Commit an exact version in .fvmrc, then in CI install FVM, run fvm install with no argument to fetch the pinned SDK, and run every step through fvm flutter. In a multi-app repository, each app resolves the nearest .fvmrc.

fvm flutter runs the pinned SDK; fvm spawn <version> runs one command on another version with the pin unchanged; fvm flavor <name> uses a version named in .fvmrc; fvm exec runs any command with the pinned SDK on PATH.

A Codemagic workflow is one named pipeline under the workflows key of codemagic.yaml, committed at the repository root. It declares its machine, environment, triggers, scripts, artifacts and publishing, so one file can hold separate test and release workflows.

An App Store Connect API key (Issuer ID, Key ID, .p8 file) lets Codemagic create certificates and fetch provisioning profiles into Code signing identities. ios_signing with distribution_type and bundle_identifier installs the matching files at build time, and xcode-project use-profiles applies them.

Codemagic environment variable groups are named sets of variables defined in team or application settings, marked Secret to encrypt them, and imported by name under environment.groups. Binary files are base64-encoded before storing and decoded during the build.

Codemagic starts a workflow from its triggering section: events such as push, pull_request or tag, filtered by branch_patterns and tag_patterns and delivered by a repository webhook. cancel_previous_builds and a when block drop stale or irrelevant builds.

Use two tag-triggered workflows sharing anchors: Android with android_signing, a store-derived build number and google_play publishing to the internal track; iOS with ios_signing app_store, use-profiles and app_store_connect publishing via the API-key integration. The first Play upload is manual; App Store Connect needs an app record.