Wie erstellt man responsive und adaptive UIs in Flutter?

Question

Accepted Answer

Flutter-Apps laufen auf vielen Bildschirmgrößen (Phones, Tablets, Web, Desktop), daher ist das Erstellen von **responsiven** UIs (Anpassung an Größe) und **adaptiven** UIs (Anpassung an Plattform) wichtig. Flutter bietet Tools wie **MediaQuery**, **LayoutBuilder** und flexible Widgets dafür.

## Responsive: Anpassung an die Bildschirmgröße

```dart
// MediaQuery — get screen dimensions and adapt
final width = MediaQuery.of(context).size.width;
if (width > 600) {
  // tablet/desktop layout (e.g. side-by-side)
} else {
  // phone layout (e.g. stacked)
}

// LayoutBuilder — adapt based on the available space (parent constraints)
LayoutBuilder(builder: (context, constraints) {
  if (constraints.maxWidth > 600) return WideLayout();
  return NarrowLayout();
})
```

## Flexible Layout-Widgets

```text
✓ EXPANDED / FLEXIBLE → children share available space proportionally
✓ FractionallySizedBox → size relative to the parent
✓ Wrap → flow children to the next line when out of space
✓ AspectRatio, FittedBox → maintain ratios / fit content
✓ Avoid hardcoded sizes; use flexible/relative sizing for responsiveness
```

## Adaptive: Anpassung an die Plattform

```text
→ ADAPTIVE = adjust to the PLATFORM (iOS vs Android vs web/desktop):
  → platform-appropriate widgets (Material vs Cupertino), navigation, conventions
  → e.g. .adaptive constructors (Switch.adaptive); check the platform
→ RESPONSIVE = adjust to SCREEN SIZE; ADAPTIVE = adjust to PLATFORM/device type
```

## Muster

```text
✓ Breakpoints (e.g. <600 phone, 600-1200 tablet, >1200 desktop) → different layouts
✓ Different layouts for phone vs tablet (e.g. master-detail on tablet)
✓ OrientationBuilder → adapt to portrait/landscape
✓ SafeArea → avoid notches/system UI; test on multiple sizes
```

## Warum es wichtig ist

Es ist wichtig, zu verstehen, wie man responsive und adaptive UIs erstellt, da **Flutter-Apps auf unterschiedlichen Bildschirmgrößen und Plattformen laufen** (Phones, Tablets, Web, Desktop) und UIs über alle hinweg gut funktionieren müssen – daher ist es wertvollles praktisches Wissen.

Da Flutters Single-Codebase viele Formfaktoren ansteuert, ist das Erstellen von UIs, die sich **an verschiedene Bildschirmgrößen anpassen (responsive)** und **an verschiedene Plattformen anpassen (adaptive)**, ein echtes, wichtiges Anliegen – ein Design, das nur für ein Phone konzipiert ist, sieht auf einem Tablet oder Desktop schlecht aus.

Das Verständnis von **responsiven Techniken** – **MediaQuery** (Abrufen von Bildschirmdimensionen zur Layoutanpassung), **LayoutBuilder** (Anpassung basierend auf verfügbarem Platz/Constraints) und **flexible Layout-Widgets** (Expanded/Flexible für proportionale Platzverteilung, Wrap für fließende Inhalte, Vermeidung von hartcodierten Größen zugunsten von flexibler/relativer Größenangabe) – ist notwendig für Layouts, die sich anmutig an die Bildschirmgröße anpassen.

Das Verständnis der **adaptiven** Dimension (Anpassung an die Plattform – Verwendung plattformgerechter Widgets wie Material vs Cupertino, Konventionen und `.adaptive`-Konstruktoren) adressiert das Ziel, Apps auf jeder Plattform nativ anfühlbar zu machen.

Das Verständnis der **Unterscheidung** (responsive = Anpassung an Bildschirmgröße; adaptive = Anpassung an Plattform/Gerätetyp) klärt diese zusammenhängenden Anliegen.

Das Kennen von verbreiteten **Mustern** (Breakpoints für verschiedene Layouts, unterschiedliche Phone-/Tablet-Layouts wie Master-Detail, OrientationBuilder für Ausrichtung, SafeArea für Notches und Testen auf mehreren Größen) spiegelt praktisches responsives Design wider.

Da Flutter-Apps auf vielfältige Geräte abzielen und über alle hinweg gut funktionieren müssen (ein Schlüsselvorteil und eine Herausforderung der plattformübergreifenden Entwicklung), und da responsive/adaptive Techniken (MediaQuery, LayoutBuilder, flexible Widgets, Breakpoints, Plattformanpassung) das Mittel sind, um dies zu erreichen, ist das Verständnis von responsiven und adaptiven UIs in Flutter wertvollles, praktisch relevantes Wissen für das Erstellen von Apps, die über die vielen Bildschirmgrößen und Plattformen, auf die Flutter abzielt, gut funktionieren – ein wichtiger Punkt für die Bereitstellung guter Erfahrungen auf allen Geräten.