Add mission/drone profile management with autosave and persistence

Vervollstaendigt Doku 3.5/3.6/7.1/7.3/7.5: ein Vollbild-Verwaltungsmenue
fuer Missionen und Drohnenprofile (per Tabs umschaltbar, wie im HTML-
Demonstrator #missionsPanel gemeinsam mit der Profilliste), Autosave der
aktuell bearbeiteten Mission, Drift-Persistenz statt der bisherigen
In-Memory-only currentMissionProvider, sowie Anzeige/Zugang ueber neue
Chips in der Fusszeile (HTML-Demonstrator: #missionNameBtn/#droneNameBtn).

Datenbank (services/database/): Missions-Tabelle um updatedAt ergaenzt,
neue DroneProfiles- und AppSettingsTable-Tabellen (schemaVersion 2 mit
onUpgrade-Migration). Drei Repositories kapseln Drift-Zugriff +
JSON-(De-)Serialisierung der Wegpunktliste: MissionRepository,
DroneProfileRepository, AppSettingsRepository - je mit Unit-Tests gegen
eine In-Memory-Datenbank (NativeDatabase.memory()).

Provider: CurrentMissionMetaNotifier haelt Name/id der aktuellen Mission
und autosaved sie 800ms-debounced (identisch zum HTML-Demonstrator:
scheduleAutosave()/flushPendingAutosave()) - inklusive Wiederherstellung
des zuletzt bearbeiteten Autosave-Drafts beim App-Start (Doku 7.5).
ActiveDroneProfileNotifier haelt das aktive Profil, seedet beim ersten
Start automatisch T1 Ranger und merkt sich die Auswahl ueber
AppSettingsTable neustart-fest.

UI: MissionsDronesPanel (Missions-Tab: Liste mit Umbenennen/Loeschen/
Laden; Drones-Tab: Liste mit Bearbeiten/Loeschen/Auswaehlen, faellt beim
Loeschen des aktiven Profils auf das naechste zurueck). DroneProfileEditor
als Formular (bewusste Vereinfachung gegenueber den Swipe-Gesten-Chips
des HTML-Demonstrators - bei elf Feldern ist ein normales Formular auf
einem Mobilgeraet zugaenglicher). Rename per AlertDialog+TextField statt
Browser-prompt().

Aktives Drohnenprofil ist jetzt tatsaechlich wirksam statt nur eine feste
Anzeige: Speed-/Alt-Drehrad-Grenzen, Fangradius neuer Wegpunkte und die
Flugpfad-Machbarkeitspruefung (Kurvenradius, Steig-/Sinkrate) in
PlanScreen und WaypointListPanel lesen jetzt activeDroneProfileProvider
statt der bisherigen statischen DefaultDroneProfile-Konstanten (die als
T1-Ranger-Seed-Werte weiterleben).

Beim Verifizieren zwei echte Bugs in BottomStatsBar gefunden und
gefixt: ein Stack+Align-ohne-Factor blaehte sich auf unbegrenzte Groesse
auf und verschob die Details-Pille aus ihrer sichtbaren Position (durch
zwei gleich grosse Expanded-Bereiche ersetzt); zwei ConstrainedBox-Chips
nebeneinander verursachten auf schmaleren Breiten einen RenderFlex-
Overflow (durch Flexible ersetzt).

Widget-Tests: AppShell/PlanScreen initialisieren beim Start jetzt die
echte Datenbank - alle Tests, die AppShell pumpen, ueberschreiben
appDatabaseProvider testweise mit einer In-Memory-Instanz. Ausserdem
mussten mehrere Tests den neuen 800ms-Autosave-Timer abwarten (wie
zuvor schon beim WaypointChip-Flash-Timer etabliert), damit nach
Testende kein Timer mehr aussteht.

Verifiziert: flutter analyze (0 issues), flutter test (59/59, davon 14
neue Repository-Tests), manuell auf Pixel_10a-Emulator - Wegpunkte
werden automatisch als "New mission" gespeichert und erscheinen in der
Liste, Umbenennen/Laden/Loeschen funktionieren, neues Drohnenprofil mit
abweichender Max-Speed wird angelegt+aktiviert+in der Fusszeile
angezeigt, Loeschen des aktiven Profils faellt auf das verbleibende
zurueck.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app/lib/ui/providers/active_drone_profile_provider.dart

@@ -0,0 +1,62 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../domain/mission/drone_profile.dart';
+import 'database_provider.dart';
+
+/// Haelt das aktuell aktive Drohnenprofil (Doku 3.5/7.3) - bestimmt u.a. den
+/// gueltigen Geschwindigkeits-/Hoehenbereich der Drehraeder sowie die
+/// Flugpfad-Machbarkeitspruefung (Kurvenradius, Steig-/Sinkrate).
+///
+/// T1-Ranger-Konstanten dienen nur als Startwert, bevor initialize() die
+/// Datenbank gelesen hat (verhindert einen Zustand ganz ohne Profil waehrend
+/// des asynchronen Ladens).
+class ActiveDroneProfileNotifier extends Notifier<DroneProfile> {
+  @override
+  DroneProfile build() => DroneProfile.t1Ranger();
+
+  /// Stellt sicher, dass mindestens ein Profil in der Datenbank existiert,
+  /// und laedt das zuletzt aktive (oder das erste vorhandene) Profil -
+  /// analog dem drones/activeDrone-Bootstrap im HTML-Demonstrator.
+  Future<void> initialize() async {
+    final droneRepo = ref.read(droneProfileRepositoryProvider);
+    final settingsRepo = ref.read(appSettingsRepositoryProvider);
+
+    final seededId = await droneRepo.ensureSeeded();
+    final settings = await settingsRepo.load();
+    final all = await droneRepo.loadAll();
+
+    final activeId = settings.activeDroneProfileId ?? seededId;
+    final active = all.firstWhere(
+      (p) => p.id == activeId,
+      orElse: () => all.first,
+    );
+    state = active;
+    if (settings.activeDroneProfileId != active.id) {
+      await settingsRepo.setActiveDroneProfileId(active.id);
+    }
+  }
+
+  Future<void> select(DroneProfile profile) async {
+    state = profile;
+    await ref.read(appSettingsRepositoryProvider).setActiveDroneProfileId(profile.id);
+  }
+
+  /// Nach dem Bearbeiten des aktiven Profils dessen Werte neu einlesen.
+  Future<void> reloadIfActive(int id) async {
+    if (state.id != id) return;
+    final all = await ref.read(droneProfileRepositoryProvider).loadAll();
+    final updated = all.where((p) => p.id == id);
+    if (updated.isNotEmpty) state = updated.first;
+  }
+
+  /// Nach dem Loeschen des aktiven Profils auf das erste verbleibende
+  /// zurueckfallen (analog `if (wasActive) applyDroneProfile(drones[0])`).
+  Future<void> fallBackTo(DroneProfile profile) async {
+    state = profile;
+    await ref.read(appSettingsRepositoryProvider).setActiveDroneProfileId(profile.id);
+  }
+}
+
+final activeDroneProfileProvider =
+    NotifierProvider<ActiveDroneProfileNotifier, DroneProfile>(
+        ActiveDroneProfileNotifier.new);

app/lib/ui/providers/database_provider.dart

@@ -0,0 +1,36 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../domain/mission/drone_profile.dart';
+import '../../services/database/app_database.dart' hide DroneProfile;
+import '../../services/database/app_settings_repository.dart';
+import '../../services/database/drone_profile_repository.dart';
+import '../../services/database/mission_repository.dart';
+
+/// App-lebenslange Drift-Datenbankinstanz (Doku 4.15).
+final appDatabaseProvider = Provider<AppDatabase>((ref) {
+  final db = AppDatabase();
+  ref.onDispose(db.close);
+  return db;
+});
+
+final missionRepositoryProvider = Provider<MissionRepository>(
+  (ref) => MissionRepository(ref.watch(appDatabaseProvider)),
+);
+
+final droneProfileRepositoryProvider = Provider<DroneProfileRepository>(
+  (ref) => DroneProfileRepository(ref.watch(appDatabaseProvider)),
+);
+
+final appSettingsRepositoryProvider = Provider<AppSettingsRepository>(
+  (ref) => AppSettingsRepository(ref.watch(appDatabaseProvider)),
+);
+
+/// Reaktive Missionsliste fuers Verwaltungsmenue (Doku 3.6/7.1).
+final missionSummariesProvider = StreamProvider(
+  (ref) => ref.watch(missionRepositoryProvider).watchSummaries(),
+);
+
+/// Reaktive Drohnenprofil-Liste fuers Verwaltungsmenue (Doku 3.5/7.3).
+final droneProfilesProvider = StreamProvider<List<DroneProfile>>(
+  (ref) => ref.watch(droneProfileRepositoryProvider).watchAll(),
+);

app/lib/ui/providers/mission_meta_provider.dart

@@ -0,0 +1,122 @@
+import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import 'current_mission_provider.dart';
+import 'database_provider.dart';
+
+/// Metadaten der aktuell in Bearbeitung befindlichen Mission - ergaenzt
+/// currentMissionProvider (das nur die Wegpunkte haelt) um Name/Ort und die
+/// Datenbank-id, sobald die Mission mindestens einmal gespeichert wurde.
+class MissionMeta {
+  const MissionMeta({this.id, this.name = 'New mission', this.placeName});
+
+  /// Null, solange die Mission noch nie (auto-)gespeichert wurde.
+  final int? id;
+  final String name;
+  final String? placeName;
+
+  MissionMeta copyWith({int? id, String? name, String? placeName}) {
+    return MissionMeta(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      placeName: placeName ?? this.placeName,
+    );
+  }
+}
+
+/// Haelt Name/id der aktuellen Mission und autosaved sie ueber
+/// MissionRepository (Doku 7.5), sobald sich die Wegpunktliste aendert -
+/// analog scheduleAutosave()/flushPendingAutosave() im HTML-Demonstrator
+/// (dort 800ms debounce, hier identisch uebernommen).
+class CurrentMissionMetaNotifier extends Notifier<MissionMeta> {
+  Timer? _autosaveTimer;
+  bool _suppressAutosave = false;
+
+  @override
+  MissionMeta build() {
+    ref.listen(currentMissionProvider, (previous, next) {
+      if (!_suppressAutosave) _scheduleAutosave();
+    });
+    ref.onDispose(() => _autosaveTimer?.cancel());
+    return const MissionMeta();
+  }
+
+  /// Laedt die zuletzt bearbeitete Mission (falls vorhanden) beim App-Start
+  /// wieder, damit ein Autosave-Draft einen Neustart ueberlebt (Doku 7.5).
+  Future<void> restoreLastSession() async {
+    final settings = await ref.read(appSettingsRepositoryProvider).load();
+    final missionId = settings.currentMissionId;
+    if (missionId == null) return;
+    final loaded = await ref.read(missionRepositoryProvider).load(missionId);
+    if (loaded == null) return;
+
+    _suppressAutosave = true;
+    ref.read(currentMissionProvider.notifier).replaceAll(loaded.waypoints);
+    _suppressAutosave = false;
+    state = MissionMeta(id: missionId, name: loaded.name, placeName: loaded.placeName);
+  }
+
+  /// Analog startNewMission() im HTML-Demonstrator: sichert zuerst noch
+  /// ausstehende Aenderungen der bisherigen Mission, dann leerer Neustart.
+  Future<void> startNew() async {
+    await _flushNow();
+    _suppressAutosave = true;
+    ref.read(currentMissionProvider.notifier).replaceAll(const []);
+    _suppressAutosave = false;
+    state = const MissionMeta();
+    await ref.read(appSettingsRepositoryProvider).setCurrentMissionId(null);
+  }
+
+  Future<void> loadMission(int id) async {
+    await _flushNow();
+    final loaded = await ref.read(missionRepositoryProvider).load(id);
+    if (loaded == null) return;
+
+    _suppressAutosave = true;
+    ref.read(currentMissionProvider.notifier).replaceAll(loaded.waypoints);
+    _suppressAutosave = false;
+    state = MissionMeta(id: id, name: loaded.name, placeName: loaded.placeName);
+    await ref.read(appSettingsRepositoryProvider).setCurrentMissionId(id);
+  }
+
+  /// Benennt eine gespeicherte Mission um (Doku 3.6: nur ueber die
+  /// Missionsliste moeglich, dort hat jede Zeile immer bereits eine id).
+  /// Aktualisiert zusaetzlich den eigenen Zustand, falls [id] die gerade
+  /// aktive Mission ist.
+  Future<void> renameMission(int id, String name) async {
+    await ref.read(missionRepositoryProvider).rename(id, name);
+    if (state.id == id) {
+      state = state.copyWith(name: name);
+    }
+  }
+
+  void _scheduleAutosave() {
+    if (ref.read(currentMissionProvider).isEmpty) return;
+    _autosaveTimer?.cancel();
+    _autosaveTimer = Timer(const Duration(milliseconds: 800), () {
+      unawaited(_flushNow());
+    });
+  }
+
+  Future<void> _flushNow() async {
+    _autosaveTimer?.cancel();
+    _autosaveTimer = null;
+    final waypoints = ref.read(currentMissionProvider);
+    if (waypoints.isEmpty) return;
+    final id = await ref.read(missionRepositoryProvider).upsert(
+          id: state.id,
+          name: state.name,
+          placeName: state.placeName,
+          waypoints: waypoints,
+        );
+    if (state.id == null) {
+      state = state.copyWith(id: id);
+    }
+    await ref.read(appSettingsRepositoryProvider).setCurrentMissionId(id);
+  }
+}
+
+final currentMissionMetaProvider =
+    NotifierProvider<CurrentMissionMetaNotifier, MissionMeta>(
+        CurrentMissionMetaNotifier.new);