Skip to content

6. Asynchrone Verarbeitung und gemeinsamer Zustand

6.1. Beispiel 19: Future, Stream und Timer

Vieles geschieht „später“: Ticks eines Timers, Tastendrücke, die Antwort eines Servers. [Dart] hat dafür zwei Typen, die den Kern der Sprache bilden:

  • [Future<T>]: EIN Wert, später (die Antwort eines Servers, eine in einem Fenster getroffene Auswahl);
  • [Stream<T>]: eine FOLGE von Werten über die Zeit (Ticks, Nachrichten, GPS-Positionen ...).

[Flutter] hat für jeden dieser Typen ein Widget, das neu aufgebaut wird, wenn ein Wert eintrifft: [FutureBuilder] und [StreamBuilder]. Und für alles, was nach einer Verzögerung geschehen muss: [Timer].

// =========================================================================
// lib/ex19_asynchronous/main.dart - Future, Stream, Timer
// -------------------------------------------------------------------------
// Vieles geschieht "später": die Ticks eines Timers, die
// Tastendrücke, die Antwort eines Servers. Dart hat dafür zwei Typen,
// im Kern der Sprache:
//   - Future<T>: EIN Wert, später (die Antwort eines Servers);
//   - Stream<T>: eine FOLGE von Werten über die Zeit (Ticks,
//     Nachrichten ...).
// Flutter hat für jeden ein Widget zur Anzeige, das sich neu baut, wenn
// ein Wert ankommt: FutureBuilder und StreamBuilder.
// Und für das, was nach einer Verzögerung geschehen muss: Timer (dart:async).
// =========================================================================

import 'dart:async';
import 'dart:math';

import 'package:flutter/material.dart';

const doctors = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];
final _random = Random();

// ein simulierter "Server": Die Antwort (ein Future) kommt nach einer zufälligen Verzögerung an
Future<List<String>> search(String text) async {
  await Future<void>.delayed(Duration(milliseconds: 200 + _random.nextInt(600)));
  return doctors.where((m) => m.toLowerCase().contains(text)).toList();
}

// 1. ein Stream, erzeugt von einer "async*"-Funktion: Jedes yield SENDET einen
// Wert an die, die den Stream abhören
Stream<int> countdown(int start) async* {
  for (var remaining = start; remaining >= 0; remaining--) {
    yield remaining;
    if (remaining > 0) await Future<void>.delayed(const Duration(seconds: 1));
  }
}

String currentTime() => DateTime.now().toString().substring(11, 19);

void main() {
  runApp(
    MaterialApp(
      debugShowCheckedModeBanner: false,
      theme: ThemeData(colorSchemeSeed: Colors.indigo),
      home: const AsynchronousPage(),
    ),
  );
}

class AsynchronousPage extends StatefulWidget {
  const AsynchronousPage({super.key});

  @override
  State<AsynchronousPage> createState() => _AsynchronousPageState();
}

class _AsynchronousPageState extends State<AsynchronousPage> {
  final List<String> _log = [];
  // Der Stream und das Future werden EINMAL erzeugt (und nicht bei jedem build:
  // Jeder Aufruf von build würde den Countdown neu starten!)
  final Stream<int> _countdown = countdown(20);
  // 3. ein Future, das nach einer Sekunde abgeschlossen wird
  final Future<String> _message = Future.delayed(const Duration(seconds: 1), () => 'three (one second later)');

  // 2. die Suche während der Eingabe
  Timer? _debounce;
  int _requestNumber = 0; // die Nummer der ZULETZT gestarteten Suche
  List<String> _results = [];

  void _trace(String message) => setState(() => _log.add('${currentTime()} $message'));

  // bei jedem Tastendruck aufgerufen
  void _onInput(String text) {
    // das DEBOUNCE: Jeder Tastendruck bricht den Timer des vorherigen
    // Tastendrucks ab; die Suche startet erst nach 400 ms ohne Tastendruck
    _debounce?.cancel();
    _debounce = Timer(const Duration(milliseconds: 400), () => _launch(text.trim().toLowerCase()));
  }

  Future<void> _launch(String text) async {
    // weniger als zwei Buchstaben: keine Suche, kein Ergebnis
    if (text.length < 2) {
      _requestNumber++; // eine noch erwartete Antwort wird ignoriert
      setState(() => _results = []);
      return;
    }
    // "stale": Eine Antwort, die ankommt, NACHDEM eine andere Suche
    // gestartet wurde, muss ignoriert werden (sonst würde die langsame Antwort einer alten
    // Suche die der neuen überschreiben)
    final number = ++_requestNumber;
    _trace('search sent: "$text"');
    final found = await search(text);
    if (!mounted) return;
    if (number != _requestNumber) {
      _trace('response ignored (stale): "$text"');
      return;
    }
    setState(() => _results = found);
  }

  @override
  void dispose() {
    _debounce?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final titleStyle = Theme.of(context).textTheme.titleSmall;
    return Scaffold(
      appBar: AppBar(title: const Text('Example 19 - asynchrony')),
      body: ListView(
        padding: const EdgeInsets.all(16),
        children: [
          Card(
            child: Padding(
              padding: const EdgeInsets.all(12),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text('A countdown (a Stream and StreamBuilder)', style: titleStyle),
                  // StreamBuilder: baut seinen Inhalt bei jedem Wert des Streams neu;
                  // snapshot.data: der zuletzt empfangene Wert (null vor dem ersten)
                  StreamBuilder<int>(
                    stream: _countdown,
                    builder: (context, snapshot) =>
                        Text(snapshot.hasData ? '${snapshot.data}' : '...', style: Theme.of(context).textTheme.displaySmall),
                  ),
                ],
              ),
            ),
          ),
          Card(
            child: Padding(
              padding: const EdgeInsets.all(12),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text('A search as you type (debounce, stale responses)', style: titleStyle),
                  TextField(
                    decoration: const InputDecoration(hintText: 'at least two letters: pel, dur...'),
                    onChanged: _onInput,
                  ),
                  for (final r in _results) Text('• $r'),
                  if (_results.isEmpty) const Text('no result', style: TextStyle(color: Colors.grey)),
                ],
              ),
            ),
          ),
          Card(
            child: Padding(
              padding: const EdgeInsets.all(12),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text('Waiting for a Future (FutureBuilder)', style: titleStyle),
                  // solange das Future nicht abgeschlossen ist: der Warteinhalt
                  FutureBuilder<String>(
                    future: _message,
                    builder: (context, snapshot) => switch (snapshot.connectionState) {
                      ConnectionState.done => Text('received: ${snapshot.data}'),
                      _ => const Text('waiting...', style: TextStyle(color: Colors.grey)),
                    },
                  ),
                ],
              ),
            ),
          ),
          Text('Log', style: titleStyle),
          for (final (i, line) in _log.indexed) Text('${i + 1}. $line', style: const TextStyle(fontSize: 12)),
        ],
      ),
    );
  }
}
  • Zeilen 24–26: ein simulierter „Server“: eine [async]-Funktion, deren Antwort (ein [Future]) nach einer zufälligen Verzögerung eintrifft. [await Future<void>.delayed(...)] wartet auf diese Verzögerung, ohne die Anwendung zu blockieren;
  • Zeilen 31–34: ein [Stream] , der von einer [async*] -Funktion (mit Sternchen) erzeugt wird: ein asynchroner Generator. Jedes [yield] sendet einen Wert an diejenigen, die [Stream] abhören; zwischen den Werten wartet die Funktion eine Sekunde;
  • Zeilen 61–63: [Stream] und [Future] werden EINMAL erzeugt, in Feldern des [State]-Objekts und nicht in [build]: Jeder Neuaufbau würde den Countdown neu starten! Das ist der häufigste Fehler bei [FutureBuilder] und [StreamBuilder];
  • Zeilen 66–68: der Status der Suche während der Eingabe: ein Timer, die Nummer der zuletzt gestarteten Suche und die Ergebnisse;
  • Zeilen 73–77: Debouncing: Das Programm wartet, bis der Benutzer eine Pause macht, bevor es den Server abfragt, statt bei jedem Tastendruck eine Anfrage zu senden. Jeder Tastendruck setzt den Timer des vorherigen Tastendrucks zurück ([cancel()]) und startet einen neuen: Die Suche wird erst nach 400 Millisekunden ohne Tastendruck ausgelöst;
  • Zeilen 80–98: die Suche. Eine „veraltete“ Antwort (eine, die eintrifft, NACHDEM eine andere Suche gestartet wurde) muss ignoriert werden: Andernfalls würde die langsame Antwort einer alten Suche die der neuen überschreiben. Jeder Suche wird eine Nummer zugewiesen ([++_requestNumber]); trifft ihre Antwort ein und ist es nicht mehr die Nummer der neuesten Suche, wird sie ignoriert. [if (!mounted) return;]: Der Bildschirm kann während des Wartens verschwunden sein;
  • Zeilen 102–104: Der Timer wird gestoppt, wenn der Bildschirm verschwindet;
  • Zeilen 124–127: [StreamBuilder] hört [Stream] ab und baut seinen Inhalt bei jedem neuen Wert neu auf. [builder] erhält einen Snapshot ([snapshot], ein [AsyncSnapshot]): [snapshot.hasData], [snapshot.data] (der zuletzt empfangene Wert), [snapshot.hasError], [snapshot.connectionState]. Verschwindet das Widget, meldet [StreamBuilder] sich von selbst ab;
  • Zeilen 158–162: [FutureBuilder] wartet auf [Future]: Bis es abgeschlossen ist, wird der Platzhalterinhalt angezeigt, danach sein Wert. [switch] auf [snapshot.connectionState] wählt das eine oder das andere.

Wir tippen schnell „p“, „pe“, „pel“: Es wird nur eine Suche gesendet. Dann „du“, gefolgt von „dup“ vor der Antwort: Die Antwort auf „du“ trifft zu spät ein und wird ignoriert, wenn „dup“ seine Antwort bereits erhalten hat:

In [JavaScript]wird dasselbe mit Promises und Timern geschrieben; [Angular] fügt die „Observables“ von [RxJS] hinzu. In [Dart] gehören [Future] und [Stream] zur Basisbibliothek, und [async], [await], [async*], [yield] und [await for] sind Teil der Sprache: Deshalb benötigt [Flutter] für asynchrone Operationen keine Bibliothek.

6.2. Beispiel 20: Ein gemeinsamer Zustand

Dieselbe Frage wie in den vorherigen Lektionen: Welche „Gültigkeitsbereiche“ gibt es für die Daten einer Anwendung?

  • Der lokale Zustand eines Widgets verschwindet, wenn das Widget entfernt wird;
  • der Zustand eines „Stores“ wird von allen Widgets geteilt und überlebt deren Entfernung ... aber nicht das Beenden der Anwendung;
  • Auf dem Gerät gespeicherter Zustand überlebt das Beenden der Anwendung.

6.2.1. Der Warenkorb

// =========================================================================
// lib/ex20_shared_state/stores/cart.dart - ein GETEILTER ZUSTAND, mit provider
// -------------------------------------------------------------------------
// Ein "Store" ist ein Zustand, der AUSSERHALB der Bildschirme lebt, in einer EINZIGEN
// Instanz, geteilt von allen, die ihn lesen. Beispiel 14 hat das von Hand gemacht
// (InheritedNotifier); das Paket provider, das mit Flutter am häufigsten verwendete
// (und in dessen Dokumentation empfohlene), macht dasselbe
// in einer Zeile:
//
//     ChangeNotifierProvider(create: (_) => Cart(), child: ...)
//
// Der Store ist ein gewöhnlicher ChangeNotifier. Übliche Organisation:
//   - der ZUSTAND: PRIVATE Daten (_items);
//   - die AKTIONEN: Methoden, die einzigen, die den Zustand ändern und die mit
//     notifyListeners() enden;
//   - die berechneten Werte: Getter.
// Ein Widget greift über seinen Kontext darauf zu:
//   - context.watch<Cart>()  : lesen UND abonnieren (bei jeder Änderung neu gebaut);
//   - context.read<Cart>()   : lesen ohne zu abonnieren (um eine Aktion aufzurufen);
//   - context.select<Cart, int>((p) => p.count) : EINEN Wert abonnieren:
//     nur neu gebaut, wenn sich DIESER Wert ändert.
// Der Store lebt, solange sein Provider lebt: Er überlebt das Entfernen eines
// Bildschirms ... aber nicht das Beenden der Anwendung.
// =========================================================================

import 'package:flutter/foundation.dart';

typedef Item = ({String label, double price});

class Cart extends ChangeNotifier {
  final List<Item> _items = [];

  // eine UNVERÄNDERLICHE Sicht auf die Liste: Nur die Aktionen ändern sie
  List<Item> get items => List.unmodifiable(_items);
  int get count => _items.length;
  double get total => _items.fold(0, (s, a) => s + a.price);

  void add(Item item) {
    _items.add(item);
    notifyListeners();
  }

  void clear() {
    _items.clear();
    notifyListeners();
  }
}

Ein Store ist ein Zustand, der sich über mehrere Bildschirme erstreckt und als einzige Instanz existiert, die von allen geteilt wird, die darauf zugreifen. Beispiel 14 hat dies manuell umgesetzt. Das Paket [provider], das am häufigsten verwendete zusammen mit [Flutter] (und das in dessen Dokumentation empfohlene), leistet dasselbe in einer einzigen Zeile: [ChangeNotifierProvider(create: (_) => Cart(), child: ...)].

  • Zeile 31: der Zustand: private Daten;
  • Zeilen 34–36: berechnete Werte: Getter. [List.unmodifiable]: eine schreibgeschützte Sicht auf die Liste; nur Aktionen können sie ändern;
  • Zeilen 38–45: die Aktionen: Methoden – die einzigen, die den Zustand ändern –, die mit [notifyListeners()] enden.

6.2.2. Einstellungen

// =========================================================================
// lib/ex20_shared_state/stores/preferences.dart - ein Zustand, der das Beenden überlebt
// -------------------------------------------------------------------------
// Damit ein Datum das Beenden der Anwendung überlebt, muss es AUF DEM GERÄT gespeichert werden.
// Das Paket shared_preferences bietet ein kleines Wörterbuch
// Schlüssel -> Wert (bool, int, double, String), spezifisch für die Anwendung und
// auf dem Gerät gespeichert (im Web: im localStorage des Browsers).
//   - beim Start werden die gespeicherten Werte gelesen (main.dart);
//   - bei jeder Änderung werden sie neu geschrieben.
// Speichern Sie dort NIEMALS sensible Daten (Passwort, Token): Sie werden
// im Klartext geschrieben.
// =========================================================================

import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';

class Preferences extends ChangeNotifier {
  static const _darkKey = 'example20.dark';
  static const _sizeKey = 'example20.size';

  final SharedPreferences _storage;
  bool _dark;
  double _size; // Textgröße

  // der Anfangszustand: was das Gerät gespeichert hat, sonst die Standardwerte
  Preferences(this._storage)
    : _dark = _storage.getBool(_darkKey) ?? false,
      _size = _storage.getDouble(_sizeKey) ?? 16;

  bool get dark => _dark;
  double get size => _size;

  // ein optionaler benannter Parameter pro Einstellung: Nur das Angegebene ändert sich
  void update({bool? dark, double? size}) {
    if (dark != null) {
      _dark = dark;
      _storage.setBool(_darkKey, dark); // auf das Gerät schreiben
    }
    if (size != null) {
      _size = size;
      _storage.setDouble(_sizeKey, size);
    }
    notifyListeners();
  }
}

Damit Daten nach dem Beenden der Anwendung erhalten bleiben, müssen sie auf dem Gerät gespeichert werden. Das Paket [shared_preferences] bietet ein kleines Schlüssel->Wert-Wörterbuch ([bool], [int], [double], [String]), das für die Anwendung spezifisch und auf dem Gerät gespeichert ist (im Web: im [localStorage] des Browsers).

  • Zeile 21: die Speicherdaten, bei der Erzeugung empfangen;
  • Zeilen 26–28: der Anfangszustand: das, was das Gerät gespeichert hat, andernfalls Standardwerte. Die Felder werden durch die „Initialisierungsliste“ des Konstruktors (nach dem Doppelpunkt) vor dem Rumpf initialisiert;
  • Zeilen 34–43: eine einzige Aktion mit optionalen benannten Parametern: Nur die angegebenen Werte werden geändert und sofort auf das Gerät geschrieben ([setBool], [setDouble]).

Speichern Sie dort NIEMALS sensible Daten (Passwörter, Token): Solche Daten werden im Klartext geschrieben. Dafür gibt es das Paket [flutter_secure_storage], das den Tresor des Systems verwendet ([Keystore] von [Android], [Keychain] von [iOS]).

6.2.3. Die Widgets

// lib/ex20_shared_state/components/shop.dart - FÜGT dem geteilten Warenkorb etwas HINZU
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

import '../stores/cart.dart';

const products = <Item>[(label: 'Consultation', price: 30), (label: 'Vaccine', price: 12.5)];

class Shop extends StatelessWidget {
  const Shop({super.key});

  @override
  Widget build(BuildContext context) {
    // read: Wir RUFEN nur eine Aktion AUF; Shop wird nicht
    // neu gebaut, wenn sich der Warenkorb ändert
    final cart = context.read<Cart>();
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(12),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text('Shop', style: Theme.of(context).textTheme.titleSmall),
            for (final p in products)
              TextButton.icon(
                icon: const Icon(Icons.add),
                label: Text('${p.label} (${p.price} €)'),
                onPressed: () => cart.add(p),
              ),
          ],
        ),
      ),
    );
  }
}
  • Zeile 16: [context.read<Cart>()] liest den oben bereitgestellten Warenkorb; OHNE Abonnement: Der Store ruft lediglich eine Aktion auf; er muss nicht neu aufgebaut werden, wenn sich der Warenkorb ändert.
// lib/ex20_shared_state/components/cart_summary.dart - LIEST denselben Warenkorb
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

import '../stores/cart.dart';

class CartSummary extends StatelessWidget {
  const CartSummary({super.key});

  @override
  Widget build(BuildContext context) {
    // select: baut NUR neu, wenn sich die Anzahl oder die Summe ändert
    final count = context.select<Cart, int>((p) => p.count);
    final total = context.select<Cart, double>((p) => p.total);
    return Card(
      child: Padding(
        padding: const EdgeInsets.all(12),
        child: Row(
          children: [
            const Icon(Icons.shopping_cart),
            const SizedBox(width: 8),
            Expanded(child: Text('$count item(s), $total €')),
            TextButton(
              onPressed: count == 0 ? null : () => context.read<Cart>().clear(),
              child: const Text('Clear'),
            ),
          ],
        ),
      ),
    );
  }
}
  • Zeilen 13–14: [context.select] liest EINEN Wert des Warenkorbs und abonniert das Widget für DIESEN Wert: Es wird nur neu aufgebaut, wenn sich dieser Wert ändert. [context.watch<Cart>()] würde den gesamten Warenkorb lesen und abonnieren.
// lib/ex20_shared_state/components/local_counter.dart - ein LOKALER Zustand, der mit dem Widget verschwindet
import 'package:flutter/material.dart';

class LocalCounter extends StatefulWidget {
  final String title;

  const LocalCounter({super.key, required this.title});

  @override
  State<LocalCounter> createState() => _LocalCounterState();
}

class _LocalCounterState extends State<LocalCounter> {
  int _clicks = 0;

  @override
  Widget build(BuildContext context) {
    return Card(
      child: ListTile(
        title: Text(widget.title),
        trailing: OutlinedButton(onPressed: () => setState(() => _clicks++), child: Text('$_clicks click(s)')),
      ),
    );
  }
}

Ein lokaler Zustand, der mit dem Widget verschwindet.

6.2.4. Die Anwendung

// =========================================================================
// lib/ex20_shared_state/main.dart - drei "Gültigkeitsbereiche" von Daten
// -------------------------------------------------------------------------
//   - der LOKALE Zustand eines Widgets (LocalCounter) verschwindet mit ihm;
//   - der Zustand eines STORES (der Warenkorb) wird von allen Widgets geteilt
//     und überlebt ihr Entfernen - aber nicht das Beenden der Anwendung;
//   - der auf dem Gerät gespeicherte Zustand (die Einstellungen) überlebt das Beenden.
// Und Visibility(maintainState: true): Der Inhalt ist VERSTECKT, aber nicht
// entfernt; sein lokaler Zustand bleibt erhalten.
// Entfernen Sie den Haken bei "Bereich anzeigen" und setzen Sie ihn wieder, beenden und starten Sie dann
// die Anwendung neu: Vergleichen Sie.
// =========================================================================

import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';

import 'components/shop.dart';
import 'components/local_counter.dart';
import 'components/cart_summary.dart';
import 'stores/cart.dart';
import 'stores/preferences.dart';

Future<void> main() async {
  // unverzichtbar vor der Verwendung eines "Plugins" (Code speziell für Android, iOS,
  // Web ...) wie shared_preferences, VOR runApp
  WidgetsFlutterBinding.ensureInitialized();
  final storage = await SharedPreferences.getInstance();
  runApp(
    // MultiProvider: mehrere ineinander verschachtelte Provider
    // oberhalb der gesamten Anwendung
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (_) => Cart()),
        ChangeNotifierProvider(create: (_) => Preferences(storage)),
      ],
      child: const Application(),
    ),
  );
}

class Application extends StatelessWidget {
  const Application({super.key});

  @override
  Widget build(BuildContext context) {
    // watch: Die Anwendung wird neu gebaut, wenn sich die Einstellungen ändern
    final preferences = context.watch<Preferences>();
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      theme: ThemeData(colorSchemeSeed: Colors.indigo),
      // das dunkle Theme und die Wahl zwischen beiden
      darkTheme: ThemeData(colorSchemeSeed: Colors.indigo, brightness: Brightness.dark),
      themeMode: preferences.dark ? ThemeMode.dark : ThemeMode.light,
      // builder: umschließt ALLE Bildschirme; hier die Textgröße
      builder: (context, child) => MediaQuery(
        data: MediaQuery.of(context).copyWith(textScaler: TextScaler.linear(preferences.size / 16)),
        child: child!,
      ),
      home: const SharedStatePage(),
    );
  }
}

class SharedStatePage extends StatefulWidget {
  const SharedStatePage({super.key});

  @override
  State<SharedStatePage> createState() => _SharedStatePageState();
}

class _SharedStatePageState extends State<SharedStatePage> {
  bool _areaVisible = true;

  @override
  Widget build(BuildContext context) {
    final preferences = context.watch<Preferences>();
    return Scaffold(
      appBar: AppBar(title: const Text('Example 20 - a shared state')),
      body: ListView(
        padding: const EdgeInsets.all(12),
        children: [
          SwitchListTile(
            title: const Text('dark theme'),
            value: preferences.dark,
            onChanged: (v) => preferences.update(dark: v),
          ),
          ListTile(
            title: Text('text size: ${preferences.size.round()}'),
            subtitle: Slider(
              value: preferences.size,
              min: 12,
              max: 22,
              divisions: 10,
              onChanged: (v) => preferences.update(size: v),
            ),
          ),
          CheckboxListTile(
            title: const Text('show the area'),
            value: _areaVisible,
            onChanged: (v) => setState(() => _areaVisible = v!),
          ),
          // entfernt: Diese Widgets verschwinden mit ihrem lokalen Zustand
          if (_areaVisible) ...[const Shop(), const CartSummary(), const LocalCounter(title: 'Local state')],
          // versteckt: Das Widget bleibt im Speicher, sein Zustand bleibt erhalten
          Visibility(
            visible: _areaVisible,
            maintainState: true,
            child: const LocalCounter(title: 'Local state, in a Visibility'),
          ),
          const Padding(
            padding: EdgeInsets.symmetric(vertical: 8),
            child: Text('Outside the area, a second summary of the SAME cart (it stays there when the area disappears):'),
          ),
          const CartSummary(),
        ],
      ),
    );
  }
}
  • Zeilen 27–28: [shared_preferences] ist ein „Plugin“: Es verwendet plattformspezifischen Code ([Android], Web ...). Um es VOR [runApp] zu verwenden, müssen Sie zunächst [Flutter] initialisieren ([ensureInitialized]). Das Lesen aus dem Speicher ist asynchron: [main] wartet auf dessen Abschluss;
  • Zeilen 32–35: [MultiProvider] platziert mehrere Provider ineinander verschachtelt an der Spitze der gesamten Anwendung. [ChangeNotifierProvider] erzeugt [ChangeNotifier] ([create]), stellt ihn seinen Nachkommen bereit, baut die Widgets neu auf, die ihn abonnieren, wenn er sich ändert, und gibt ihn frei, wenn er verschwindet;
  • Zeile 48: Die Anwendung liest die Einstellungen und abonniert sie; sie wird neu aufgebaut, wenn sie sich ändern;
  • Zeilen 53–54: zwei Themes, hell und dunkel, und die Möglichkeit, zwischen ihnen zu wählen ([themeMode]);
  • Zeilen 56–58: der [builder] von [MaterialApp] umschließt ALLE Bildschirme. Hier wird die Textgröße der gesamten App geändert: [MediaQuery] beschreibt den Bildschirm und die Einstellungen des Benutzers (darunter [textScaler], den Vergrößerungsfaktor für Text, der auch in den Bedienungshilfen des Smartphones eingestellt werden kann);
  • Zeile 104: entfernt; der Bereich verschwindet samt dem lokalen Zustand seiner Widgets;
  • Zeilen 106–109: [Visibility] mit [maintainState: true] BLENDET sein Kind AUS, ohne es zu entfernen: Sein Zustand bleibt erhalten. (Das leistet [<Activity mode="hidden">] im Kurs zu [React].)

Wir fügen zwei Artikel hinzu, klicken einmal auf jeden lokalen Zähler (links); wir entfernen den Bereich und wechseln in den Dunkelmodus (in der Mitte); wir stellen den Bereich wieder her (rechts):

Der Warenkorb hat das Entfernen des Abschnitts überlebt (wie in der zweiten Zusammenfassung zu sehen); der entfernte Zähler wurde auf null zurückgesetzt; der ausgeblendete Zähler hat seinen Wert behalten. Beenden Sie die App und starten Sie sie neu: Das dunkle Theme und die Textgröße bleiben erhalten, und der Warenkorb ist leer.

Warum [provider]? Es gibt viele Bibliotheken zur Zustandsverwaltung für [Flutter] ([Riverpod], [Bloc], [GetX], [MobX] ...). [provider] ist die einfachste: Sie ist lediglich eine bequeme Schreibweise für das [InheritedWidget] aus Beispiel 14, das auf dem [ChangeNotifier] von [Flutter] beruht. Sie wird im Architekturleitfaden der [Flutter]-Dokumentation verwendet und kommt auch in der Fallstudie zum Einsatz.