Apple Watch: Übersicht, Ausrichten mit Vibration, Kühlbox am Handgelenk

Neues Target CamperMonitorWatch, eingebettet in die iPhone-App. Die Uhr
zeigt je Gerät den Hauptwert, die Nivellierung mit Libelle und Keilhöhen,
den Ausrichtungs-Assistenten und stellt die Kühlbox.

Die Uhr funkt nicht selbst, obwohl watchOS das könnte. BMS, Kühlbox und
Neigungsmesser lassen jeweils nur eine Verbindung zu – eine mitlesende Uhr
würde dem iPhone die Verbindung wegnehmen, statt sie zu ergänzen. Und die
Victron-Schlüssel liegen in der Keychain des iPhones; sie ein zweites Mal
auf der Uhr aufzubewahren brächte nichts. Das iPhone bleibt also das
Funkgerät und reicht fertige Messwerte über WatchConnectivity weiter.

Gesendet wird in zwei Takten: ein halber Sekundentakt als Nachricht,
solange die Watch-App im Vordergrund ist und das über eine Frist meldet,
sonst alle zwei Sekunden als Anwendungskontext und nur bei Änderungen.
Läuft die Frist ab, hört das iPhone von selbst wieder auf.

Solange die Uhr hinschaut, hält die App das Funkgerät auch im Hintergrund
am Leben (UIBackgroundModes in Config/CamperMonitor-Info.plist) – beim
Rangieren liegt das iPhone sonst mit dunklem Bildschirm in der Halterung
und die Anzeige am Handgelenk wäre genau dann tot. Die verbundenen Geräte
liefern dabei weiter, die Victron-Werbedaten nicht: ungefiltertes Suchen
lässt iOS im Hintergrund nicht zu.

Der plattformneutrale Modellcode wandert nach Shared/ und wird in beide
Targets übersetzt; LevelState ist dafür aus VanAlignProtocol.swift
herausgelöst. Datensatz und Befehle stehen in Shared/WatchLink und sind
in run-tests.sh abgesichert: Rundlauf, Schutz gegen fremde Formatversion,
Vergleich ohne Zeitstempel und die Auflösung der Zeitangaben.

Geprüft sind der Bau beider Targets samt Einbetten und der Testlauf; auf
echter Hardware noch nicht.

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

CamperMonitorWatch/Views/WatchRootView.swift

@@ -0,0 +1,164 @@
+import SwiftUI
+
+/// Der Einstieg: das Wichtigste untereinander, in der Reihenfolge, in der man
+/// im Wohnmobil danach schaut.
+struct WatchRootView: View {
+    @Environment(PhoneLink.self) private var link
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if let payload = link.payload {
+                    content(for: payload)
+                } else {
+                    waiting
+                }
+            }
+            .navigationTitle(link.payload?.profile.name ?? "Camper")
+        }
+    }
+
+    private func content(for payload: WatchPayload) -> some View {
+        List {
+            if let level = payload.levelDevice {
+                Section {
+                    NavigationLink {
+                        WatchLevelView(device: level)
+                    } label: {
+                        LevelSummaryRow(state: level.level, link: level.link)
+                    }
+                }
+            }
+
+            Section {
+                ForEach(payload.devices.filter { $0.role != .leveling }) { device in
+                    NavigationLink {
+                        WatchDeviceDetailView(deviceID: device.id)
+                    } label: {
+                        DeviceRow(device: device)
+                    }
+                }
+            }
+
+            Section {
+                FreshnessNote(payload: payload, receivedAt: link.receivedAt)
+            }
+        }
+    }
+
+    private var waiting: some View {
+        VStack(spacing: 8) {
+            Image(systemName: "iphone.gen3.radiowaves.left.and.right")
+                .font(.title2)
+                .foregroundStyle(.tint)
+            Text("Warte auf das iPhone")
+                .font(.headline)
+            Text("Die Werte kommen vom iPhone. Dort muss Camper Monitor "
+                 + "geöffnet sein.")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+        }
+        .padding(.horizontal, 4)
+    }
+}
+
+/// Eine Gerätezeile: Name klein, Hauptwert gross – auf dem kleinen Bildschirm
+/// zählt nur der eine Wert, wegen dem man den Arm hebt.
+struct DeviceRow: View {
+    let device: WatchDevice
+
+    var body: some View {
+        HStack(spacing: 8) {
+            Image(systemName: device.role.symbol)
+                .foregroundStyle(.tint)
+                .frame(width: 20)
+            VStack(alignment: .leading, spacing: 1) {
+                Text(device.name)
+                    .font(.caption2)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(1)
+                if let metric = device.snapshot?.primaryMetric, metric.value != nil {
+                    Text(metric.formattedWithUnit)
+                        .font(.title3.weight(.semibold))
+                        .monospacedDigit()
+                        .foregroundStyle(device.isLive ? .primary : .secondary)
+                } else {
+                    Text(device.link.label)
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                }
+            }
+            Spacer(minLength: 0)
+            Circle()
+                .fill(device.statusColor)
+                .frame(width: 7, height: 7)
+        }
+    }
+}
+
+/// Die Nivellierung bekommt eine eigene, grössere Zeile: sie ist der Grund,
+/// aus dem man die Uhr im Fahrzeug überhaupt anschaut.
+struct LevelSummaryRow: View {
+    let state: LevelState?
+    let link: DeviceLinkState
+
+    var body: some View {
+        HStack(spacing: 10) {
+            WatchBubble(pitch: state?.pitch, roll: state?.roll)
+                .frame(width: 44, height: 44)
+            VStack(alignment: .leading, spacing: 2) {
+                Text("Nivellierung")
+                    .font(.caption2)
+                    .foregroundStyle(.secondary)
+                // Ohne Messwerte steht hier, woran es liegt, statt eines
+                // nichtssagenden Strichs.
+                Text(state?.instruction ?? link.label)
+                    .font(.footnote.weight(.medium))
+                    .lineLimit(2)
+            }
+            Spacer(minLength: 0)
+        }
+        .padding(.vertical, 2)
+    }
+}
+
+/// Wie alt der Stand ist – auf der Uhr die wichtigste Nebenangabe. Alles hier
+/// ist weitergereicht; eine abgerissene Strecke zum iPhone sieht sonst genauso
+/// aus wie ein Fahrzeug, an dem sich nichts tut.
+struct FreshnessNote: View {
+    let payload: WatchPayload
+    let receivedAt: Date?
+
+    var body: some View {
+        TimelineView(.periodic(from: .now, by: 1)) { context in
+            let age = context.date.timeIntervalSince(receivedAt ?? payload.generatedAt)
+            Label {
+                Text(text(age: age))
+                    .font(.caption2)
+            } icon: {
+                Image(systemName: age > 10 ? "exclamationmark.triangle.fill" : "iphone.gen3")
+            }
+            .foregroundStyle(age > 10 ? .orange : .secondary)
+        }
+    }
+
+    private func text(age: TimeInterval) -> String {
+        if !payload.isRadioReady { return payload.radioStatus }
+        if age < 3 { return "Stand: eben" }
+        if age < 90 { return String(format: "Stand: vor %.0f s", age) }
+        return String(format: "Stand: vor %.0f min – iPhone erreichbar?", age / 60)
+    }
+}
+
+extension WatchDevice {
+    /// Grün heisst: der Wert ist frisch und kommt vom Gerät selbst.
+    var statusColor: Color {
+        switch link {
+        case .live:     return (snapshot?.isStale ?? true) ? .orange : .green
+        case .needsKey: return .orange
+        case .failed:   return .red
+        default:        return .gray
+        }
+    }
+}