Uhr: Neigungsmesser direkt, Fahrzeugansicht, kein Kalibrieren

Die Uhr funkt den Neigungsmesser jetzt selbst an, statt die Werte vom
iPhone weiterreichen zu lassen. Bei diesem einen Gerät geht das, und nur
bei ihm: Es bewirbt seinen Dienst, ist also ohne Einrichtung auffindbar,
und es ist unverschlüsselt – es gibt keinen Schlüssel, der auf der Uhr
ein zweites Mal lagern müsste. Damit steht die Nivellierung am Handgelenk
ohne geöffnetes iPhone, und genau dafür hebt man beim Rangieren den Arm.

Batterie, Solar und Kühlbox bleiben beim Weg über das iPhone: Sie lassen
nur eine Verbindung zu, und die Victron-Schlüssel liegen in dessen
Keychain. Die Einbaulage des Sensors reist einmal mit dem Datensatz
herüber und bleibt auf der Uhr gespeichert – ohne sie stünden längs und
quer je nach Einbau vertauscht.

LevelSession und VanAlignProtocol wandern nach Shared/Bluetooth; beide
sind reines CoreBluetooth und laufen auf watchOS unverändert. Die
Fahrzeugansicht gibt es jetzt auch auf der Uhr, umschaltbar zur Libelle;
Überhöhung und Farbregeln stehen in Shared/VehicleTilt.swift, damit
iPhone und Uhr nicht auseinanderlaufen.

Kalibrieren fällt auf der Uhr weg, samt Befehl. Das gehört einmalig ans
iPhone mit ebenem Fahrzeug; ein Knopf dafür am Handgelenk wäre vor allem
eine Gelegenheit, die Nullage aus Versehen zu verstellen.

Zwei Fehler dabei behoben:

* Beim Start meldete die Uhr dem iPhone nie, dass jemand hinschaut –
  onChange(of: scenePhase) feuert beim ersten Erscheinen nicht. Der
  schnelle Sendetakt blieb aus, bis die App einmal im Hintergrund war.
* Ein einmal direkt gemessener Wert hatte für immer Vorrang. Blieb der
  Sensor stehen, ohne die Verbindung zu trennen, klebte die Anzeige
  daran. Jetzt gilt er drei Sekunden als frisch, danach übernimmt der
  Stand des iPhones – mit Alter und Grund daneben.

Ausserdem WATCHOS_DEPLOYMENT_TARGET auf 10.0 (Xcode hatte 11.6 gesetzt)
und die Bluetooth-Begründung für das Watch-Target.

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

CamperMonitorWatch/Views/WatchAlignView.swift

@@ -10,16 +10,14 @@ import WatchKit
 /// Ortsbezug, nur der zeitliche Verlauf der Neigung. Was besser und was
 /// schlechter wird, steckt vollständig darin.
 struct WatchAlignView: View {
-    let deviceID: UUID
-
     @Environment(PhoneLink.self) private var link
+    @Environment(WatchLevelRadio.self) private var radio
     @State private var assistant = AlignmentAssistant()
     /// Damit die Vibration einmal kommt und nicht im Sekundentakt.
     @State private var hasAnnouncedTarget = false
 
-    private var state: LevelState? {
-        link.payload?.devices.first { $0.id == deviceID }?.level
-    }
+    private var reading: WatchLevelReading { WatchLevelReading(radio: radio, phone: link) }
+    private var state: LevelState? { reading.hasReading ? reading.state : nil }
 
     var body: some View {
         ScrollView {
@@ -69,21 +67,21 @@ struct WatchAlignView: View {
             .padding(.horizontal, 4)
         }
         .navigationTitle("Ausrichten")
-        .onChange(of: reading, initial: true) { _, reading in
-            guard let reading else { return }
-            assistant.add(pitch: reading.pitch, roll: reading.roll)
+        .onChange(of: tilt, initial: true) { _, tilt in
+            guard let tilt else { return }
+            assistant.add(pitch: tilt.pitch, roll: tilt.roll)
             announceIfLevel()
         }
     }
 
-    /// Ein Wertepaar als Auslöser: nur wenn sich wirklich eine Neigung ändert,
-    /// wird gerechnet – nicht bei jedem Datensatz des iPhones.
-    private var reading: Reading? {
+    /// Ein Wertepaar als Auslöser: gerechnet wird nur, wenn sich die Neigung
+    /// wirklich ändert – nicht bei jeder Aktualisierung der Anzeige.
+    private var tilt: Tilt? {
         guard let state, let pitch = state.pitch, let roll = state.roll else { return nil }
-        return Reading(pitch: pitch, roll: roll)
+        return Tilt(pitch: pitch, roll: roll)
     }
 
-    private struct Reading: Equatable {
+    private struct Tilt: Equatable {
         let pitch: Double
         let roll: Double
     }

CamperMonitorWatch/Views/WatchLevelView.swift

@@ -1,32 +1,40 @@
 import SwiftUI
 
-/// Nivellierung auf der Uhr: Libelle, Zahlen, und was zu tun ist.
+/// Nivellierung auf der Uhr.
+///
+/// Die Werte kommen bevorzugt **direkt vom Sensor** (`WatchLevelRadio`); nur
+/// wenn der gerade nicht erreichbar ist, tritt der zuletzt über das iPhone
+/// gemeldete Stand an seine Stelle. Woher sie stammen, steht unten – ein alter
+/// Wert sieht sonst aus wie ein stillstehendes Fahrzeug.
+///
+/// Kalibriert wird hier nichts. Das gehört einmalig ans iPhone, mit ebenem
+/// Fahrzeug und Ruhe dafür; auf der Uhr wäre der Knopf nur eine Gelegenheit,
+/// die Nullage aus Versehen zu verstellen.
 struct WatchLevelView: View {
-    /// Nur für den Einstieg – angezeigt wird immer der Stand aus dem letzten
-    /// Datensatz, sonst bliebe die Ansicht auf dem Wert vom Öffnen stehen.
-    let device: WatchDevice
-
     @Environment(PhoneLink.self) private var link
-    @State private var isCalibrating = false
+    @Environment(WatchLevelRadio.self) private var radio
+    @AppStorage("levelDisplayStyle") private var showsVehicle = true
 
-    private var current: WatchDevice { link.payload?.levelDevice ?? device }
-    private var state: LevelState { current.level ?? LevelState() }
+    private var reading: WatchLevelReading { WatchLevelReading(radio: radio, phone: link) }
 
     var body: some View {
         ScrollView {
-            VStack(spacing: 10) {
-                WatchBubble(pitch: state.pitch, roll: state.roll)
-                    .frame(maxWidth: 110)
-
-                HStack(spacing: 14) {
-                    angle("Längs", state.pitch)
-                    angle("Quer", state.roll)
+            VStack(spacing: 8) {
+                if showsVehicle {
+                    WatchVehicleView(pitch: reading.state.pitch, roll: reading.state.roll)
+                } else {
+                    WatchBubble(pitch: reading.state.pitch, roll: reading.state.roll)
+                        .frame(maxWidth: 110)
+                    HStack(spacing: 14) {
+                        angle("Längs", reading.state.pitch)
+                        angle("Quer", reading.state.roll)
+                    }
                 }
 
-                Text(state.instruction ?? "Keine Werte")
+                Text(reading.state.instruction ?? "Keine Werte")
                     .font(.footnote.weight(.medium))
                     .multilineTextAlignment(.center)
-                    .foregroundStyle(state.isLevel ? .green : .primary)
+                    .foregroundStyle(reading.state.isLevel ? .green : .primary)
 
                 if let wedges = wedgeText {
                     Text(wedges)
@@ -36,33 +44,25 @@ struct WatchLevelView: View {
                 }
 
                 NavigationLink {
-                    WatchAlignView(deviceID: current.id)
+                    WatchAlignView()
                 } label: {
-                    Label("Ausrichten", systemImage: "car.side.rear.and.collision.and.car.side.front")
+                    Label("Ausrichten", systemImage: "arrow.left.and.right")
                 }
                 .buttonStyle(.borderedProminent)
 
-                Button("Kalibrieren", systemImage: "scope") { isCalibrating = true }
-                    .font(.footnote)
-
-                if state.isKnownUncalibrated {
-                    Text("Noch nicht kalibriert – die Anzeige zeigt die Lage des "
-                         + "Sensors, nicht die des Fahrzeugs.")
-                        .font(.caption2)
-                        .foregroundStyle(.orange)
-                        .multilineTextAlignment(.center)
+                Button {
+                    showsVehicle.toggle()
+                } label: {
+                    Label(showsVehicle ? "Libelle" : "Fahrzeug",
+                          systemImage: showsVehicle ? "circle.circle" : "box.truck")
                 }
+                .font(.caption2)
+
+                SourceNote(reading: reading)
             }
             .padding(.horizontal, 4)
         }
         .navigationTitle("Nivellierung")
-        .confirmationDialog("Auf aktuelle Lage kalibrieren?",
-                            isPresented: $isCalibrating, titleVisibility: .visible) {
-            Button("Kalibrieren") { link.send(.calibrateLevel(device: current.id)) }
-            Button("Abbrechen", role: .cancel) {}
-        } message: {
-            Text("Nur sinnvoll, wenn das Fahrzeug jetzt eben steht.")
-        }
     }
 
     private func angle(_ title: String, _ value: Double?) -> some View {
@@ -81,14 +81,97 @@ struct WatchLevelView: View {
     private var wedgeText: String? {
         guard let profile = link.payload?.profile else { return nil }
         var parts: [String] = []
-        if let roll = state.roll, let width = profile.trackWidth,
+        if let roll = reading.state.roll, let width = profile.trackWidth,
            let wedge = LevelingWedge.across(roll: roll, trackWidth: width) {
             parts.append(String(format: "%.0f cm %@", wedge.heightInCentimetres, wedge.side.text))
         }
-        if let pitch = state.pitch, let base = profile.wheelbase,
+        if let pitch = reading.state.pitch, let base = profile.wheelbase,
            let wedge = LevelingWedge.along(pitch: pitch, wheelbase: base) {
             parts.append(String(format: "%.0f cm %@", wedge.heightInCentimetres, wedge.side.text))
         }
         return parts.isEmpty ? nil : "Keile: " + parts.joined(separator: ", ")
     }
 }
+
+/// Woher die angezeigte Neigung kommt und wie alt sie ist.
+struct SourceNote: View {
+    let reading: WatchLevelReading
+
+    var body: some View {
+        TimelineView(.periodic(from: .now, by: 1)) { context in
+            let age = reading.age(now: context.date)
+            Label {
+                Text(text(age: age))
+            } icon: {
+                Image(systemName: reading.isDirect
+                      ? "antenna.radiowaves.left.and.right" : "iphone.gen3")
+            }
+            .font(.system(size: 10))
+            .foregroundStyle(age > 5 ? .orange : .secondary)
+        }
+    }
+
+    private func text(age: TimeInterval) -> String {
+        guard reading.hasReading else { return reading.statusText }
+        let source = reading.isDirect ? "Sensor" : "iPhone"
+        if age < 3 { return "\(source), eben gemessen" }
+        // Steht der Wert, gehört der Grund dazu und nicht nur das Alter.
+        if age < 90 { return String(format: "%@, vor %.0f s · %@", source, age, reading.statusText) }
+        return String(format: "%@, vor %.0f min · %@", source, age / 60, reading.statusText)
+    }
+}
+
+/// Die angezeigte Neigung samt Herkunft.
+///
+/// Die eigene Verbindung hat Vorrang, solange sie **frisch** ist. Das „solange“
+/// ist der Punkt: Bleibt der Sensor stehen, ohne die Verbindung zu trennen,
+/// würde ein einmal gelesener Wert sonst für immer stehenbleiben – und eine
+/// eingefrorene Anzeige ist beim Ausrichten schlimmer als gar keine. Dann tritt
+/// der Stand des iPhones an seine Stelle, und wenn auch der fehlt, bleibt der
+/// alte Wert stehen, aber mit seinem Alter daneben.
+struct WatchLevelReading {
+    let state: LevelState
+    let isDirect: Bool
+    let measuredAt: Date?
+    let statusText: String
+
+    /// Ab hier gilt ein direkt gemessener Wert als überholt. Gefragt wird
+    /// zweimal je Sekunde ab; drei Sekunden Stille sind schon viel.
+    static let directLifetime: TimeInterval = 3
+
+    init(radio: WatchLevelRadio, phone: PhoneLink, now: Date = Date()) {
+        let directAge = radio.updatedAt.map { now.timeIntervalSince($0) }
+        let hasFreshDirect = radio.state.hasReading
+            && (directAge ?? .infinity) <= Self.directLifetime
+        let relayed = phone.payload?.levelDevice
+
+        if hasFreshDirect {
+            state = radio.state
+            isDirect = true
+            measuredAt = radio.updatedAt
+            statusText = radio.statusText
+        } else if let relayed, let level = relayed.level {
+            state = level
+            isDirect = false
+            measuredAt = relayed.snapshot?.timestamp ?? phone.payload?.generatedAt
+            statusText = relayed.link.label
+        } else if radio.state.hasReading {
+            state = radio.state
+            isDirect = true
+            measuredAt = radio.updatedAt
+            statusText = radio.statusText
+        } else {
+            state = LevelState()
+            isDirect = false
+            measuredAt = nil
+            statusText = radio.statusText
+        }
+    }
+
+    var hasReading: Bool { state.hasReading }
+
+    func age(now: Date = Date()) -> TimeInterval {
+        guard let measuredAt else { return 0 }
+        return now.timeIntervalSince(measuredAt)
+    }
+}

CamperMonitorWatch/Views/WatchRootView.swift

@@ -4,62 +4,62 @@ import SwiftUI
 /// im Wohnmobil danach schaut.
 struct WatchRootView: View {
     @Environment(PhoneLink.self) private var link
+    @Environment(WatchLevelRadio.self) private var radio
 
     var body: some View {
         NavigationStack {
-            Group {
-                if let payload = link.payload {
-                    content(for: payload)
-                } else {
-                    waiting
-                }
-            }
-            .navigationTitle(link.payload?.profile.name ?? "Camper")
+            content
+                .navigationTitle(link.payload?.profile.name ?? "Camper")
         }
     }
 
-    private func content(for payload: WatchPayload) -> some View {
+    private var content: some View {
         List {
-            if let level = payload.levelDevice {
+            // Die Nivellierung steht immer oben und immer da: Sie kommt vom
+            // Sensor selbst und braucht das iPhone nicht.
+            Section {
+                NavigationLink {
+                    WatchLevelView()
+                } label: {
+                    LevelSummaryRow(reading: WatchLevelReading(radio: radio, phone: link))
+                }
+            }
+
+            if let payload = link.payload {
                 Section {
-                    NavigationLink {
-                        WatchLevelView(device: level)
-                    } label: {
-                        LevelSummaryRow(state: level.level, link: level.link)
+                    ForEach(payload.devices.filter { $0.role != .leveling }) { device in
+                        NavigationLink {
+                            WatchDeviceDetailView(deviceID: device.id)
+                        } label: {
+                            DeviceRow(device: device)
+                        }
                     }
                 }
-            }
 
-            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)
+                }
+            } else {
+                Section {
+                    waiting
+                } footer: {
+                    Text("Batterie, Solar und Kühlbox kommen vom iPhone. Die "
+                         + "Nivellierung oben nicht – die geht direkt.")
+                        .font(.system(size: 10))
                 }
-            }
-
-            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.")
+        VStack(spacing: 4) {
+            Label("Warte auf das iPhone", systemImage: "iphone.gen3.radiowaves.left.and.right")
+                .font(.footnote.weight(.medium))
+            Text("Dort muss Camper Monitor geöffnet sein.")
                 .font(.caption2)
                 .foregroundStyle(.secondary)
-                .multilineTextAlignment(.center)
         }
-        .padding(.horizontal, 4)
+        .frame(maxWidth: .infinity, alignment: .leading)
     }
 }
 
@@ -100,12 +100,11 @@ struct DeviceRow: View {
 /// 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
+    let reading: WatchLevelReading
 
     var body: some View {
         HStack(spacing: 10) {
-            WatchBubble(pitch: state?.pitch, roll: state?.roll)
+            WatchBubble(pitch: reading.state.pitch, roll: reading.state.roll)
                 .frame(width: 44, height: 44)
             VStack(alignment: .leading, spacing: 2) {
                 Text("Nivellierung")
@@ -113,7 +112,9 @@ struct LevelSummaryRow: View {
                     .foregroundStyle(.secondary)
                 // Ohne Messwerte steht hier, woran es liegt, statt eines
                 // nichtssagenden Strichs.
-                Text(state?.instruction ?? link.label)
+                Text(reading.hasReading
+                     ? (reading.state.instruction ?? "Keine Werte")
+                     : reading.statusText)
                     .font(.footnote.weight(.medium))
                     .lineLimit(2)
             }

CamperMonitorWatch/Views/WatchVehicleView.swift

@@ -0,0 +1,67 @@
+import SwiftUI
+
+/// Die Neigung am Fahrzeug selbst, wie am iPhone – nur auf Uhrgrösse gebracht.
+///
+/// Zwei Ansichten, jede um ihre Achse gekippt: die Seitenansicht für längs
+/// (Front links, Heck rechts) und die Heckansicht für quer. Die Heckansicht
+/// teilt die Blickrichtung des Fahrers, links im Bild ist also links am
+/// Fahrzeug.
+struct WatchVehicleView: View {
+    let pitch: Double?
+    let roll: Double?
+
+    /// Wie am iPhone dreifach überhöht – zwei Grad wären sonst kaum zu sehen.
+    /// Die angeschriebenen Gradzahlen bleiben echt.
+    var body: some View {
+        VStack(spacing: 8) {
+            panel(image: "VehicleSide", angle: pitch, title: "Längs",
+                  lower: "Front", upper: "Heck", aspect: VehicleTilt.sideAspect)
+            panel(image: "VehicleRear", angle: roll, title: "Quer",
+                  lower: "links", upper: "rechts", aspect: VehicleTilt.rearAspect)
+        }
+    }
+
+    private func panel(image: String,
+                       angle: Double?,
+                       title: String,
+                       lower: String,
+                       upper: String,
+                       aspect: Double) -> some View {
+        VStack(spacing: 2) {
+            HStack {
+                Text(title)
+                Spacer()
+                Text(angle.map { String(format: "%.1f°", $0) } ?? "–")
+                    .monospacedDigit()
+                    .foregroundStyle(VehicleTilt.colour(for: angle))
+            }
+            .font(.caption2)
+
+            ZStack {
+                // Die Waagerechte als Bezug – ohne sie ist eine kleine Neigung
+                // nicht einzuschätzen.
+                Rectangle()
+                    .fill(Color.secondary.opacity(0.35))
+                    .frame(height: 1)
+
+                Image(image)
+                    .resizable()
+                    .scaledToFit()
+                    .foregroundStyle(VehicleTilt.colour(for: angle))
+                    .aspectRatio(aspect, contentMode: .fit)
+                    .rotationEffect(.degrees(-(angle ?? 0) * VehicleTilt.exaggeration))
+                    .animation(.spring(duration: 0.4), value: angle)
+                    .opacity(angle == nil ? 0.3 : 1)
+            }
+            .frame(height: 52)
+
+            HStack {
+                Text(lower)
+                Spacer()
+                Text(upper)
+            }
+            .font(.system(size: 9))
+            .foregroundStyle(.secondary)
+        }
+    }
+}