Solar-Integration und dev_watch-Geräte zusammenführen

solar-integration (aus dem separaten VanAligneiOS-Repo) und dev_watch haben unabhängige Git-Historien, decken aber überlappende und sich ergänzende Funktionen ab. Übernommen aus solar-integration: Votronic- Solar-ESP-Anbindung samt Geräterolle, die Live-Activity/Widget-Extension fürs Sperrbildschirm/Dynamic-Island/CarPlay, das Querformat-Layout für Libelle/Fahrzeug-Ansicht und Ausrichtungs-Assistent, sowie die mehreren Fahrzeuggrafik-Stile (Vanster/California). Beibehalten aus dev_watch: alle zusätzlichen Geräteprotokolle (Daly-/JBD-BMS, Alpicool- Kühlbox, WattCycle, Victron), die dort zwischenzeitlich entstanden. Die Xcode-Projektdatei wurde von Hand um die neue Widget-Extension samt SharedActivity-Gruppe erweitert (Datei-synchronisierte Gruppen, kein App-Group-Entitlement nötig). Build für App, Watch und Widget-Extension geprüft (Debug und Release). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-06 21:00:14 +02:00
parent 812874baef
commit e9b9c5bcd5
42 changed files with 2592 additions and 214 deletions
@@ -0,0 +1,18 @@
+//
+//  AppIntent.swift
+//  VanAligneiOSWidget
+//
+//  Created by Christopher Helberg on 02.09.26.
+//
+
+import WidgetKit
+import AppIntents
+
+struct ConfigurationAppIntent: WidgetConfigurationIntent {
+    static var title: LocalizedStringResource { "Configuration" }
+    static var description: IntentDescription { "This is an example widget." }
+
+    // An example configurable parameter.
+    @Parameter(title: "Favorite Emoji", default: "😃")
+    var favoriteEmoji: String
+}
@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
@@ -0,0 +1,35 @@
+{
+  "images" : [
+    {
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "tinted"
+        }
+      ],
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.widgetkit-extension</string>
+	</dict>
+</dict>
+</plist>
@@ -0,0 +1,90 @@
+//
+//  VanAligneiOSWidget.swift
+//  VanAligneiOSWidget
+//
+//  Created by Christopher Helberg on 02.09.26.
+//
+
+import WidgetKit
+import SwiftUI
+
+struct Provider: AppIntentTimelineProvider {
+    func placeholder(in context: Context) -> SimpleEntry {
+        SimpleEntry(date: Date(), configuration: ConfigurationAppIntent())
+    }
+
+    func snapshot(for configuration: ConfigurationAppIntent, in context: Context) async -> SimpleEntry {
+        SimpleEntry(date: Date(), configuration: configuration)
+    }
+    
+    func timeline(for configuration: ConfigurationAppIntent, in context: Context) async -> Timeline<SimpleEntry> {
+        var entries: [SimpleEntry] = []
+
+        // Generate a timeline consisting of five entries an hour apart, starting from the current date.
+        let currentDate = Date()
+        for hourOffset in 0 ..< 5 {
+            let entryDate = Calendar.current.date(byAdding: .hour, value: hourOffset, to: currentDate)!
+            let entry = SimpleEntry(date: entryDate, configuration: configuration)
+            entries.append(entry)
+        }
+
+        return Timeline(entries: entries, policy: .atEnd)
+    }
+
+//    func relevances() async -> WidgetRelevances<ConfigurationAppIntent> {
+//        // Generate a list containing the contexts this widget is relevant in.
+//    }
+}
+
+struct SimpleEntry: TimelineEntry {
+    let date: Date
+    let configuration: ConfigurationAppIntent
+}
+
+struct VanAligneiOSWidgetEntryView : View {
+    var entry: Provider.Entry
+
+    var body: some View {
+        VStack {
+            Text("Time:")
+            Text(entry.date, style: .time)
+
+            Text("Favorite Emoji:")
+            Text(entry.configuration.favoriteEmoji)
+            
+        }
+    }
+}
+
+struct VanAligneiOSWidget: Widget {
+    let kind: String = "VanAligneiOSWidget"
+
+    var body: some WidgetConfiguration {
+        AppIntentConfiguration(kind: kind, intent: ConfigurationAppIntent.self, provider: Provider()) { entry in
+            VanAligneiOSWidgetEntryView(entry: entry)
+                .containerBackground(.fill.tertiary, for: .widget)
+        
+        }
+    }
+}
+
+extension ConfigurationAppIntent {
+    fileprivate static var smiley: ConfigurationAppIntent {
+        let intent = ConfigurationAppIntent()
+        intent.favoriteEmoji = "😀"
+        return intent
+    }
+    
+    fileprivate static var starEyes: ConfigurationAppIntent {
+        let intent = ConfigurationAppIntent()
+        intent.favoriteEmoji = "🤩"
+        return intent
+    }
+}
+
+#Preview(as: .systemSmall) {
+    VanAligneiOSWidget()
+} timeline: {
+    SimpleEntry(date: .now, configuration: .smiley)
+    SimpleEntry(date: .now, configuration: .starEyes)
+}
@@ -0,0 +1,18 @@
+//
+//  VanAligneiOSWidgetBundle.swift
+//  VanAligneiOSWidget
+//
+//  Created by Christopher Helberg on 02.09.26.
+//
+
+import WidgetKit
+import SwiftUI
+
+@main
+struct VanAligneiOSWidgetBundle: WidgetBundle {
+    var body: some Widget {
+        VanAligneiOSWidget()
+        VanAligneiOSWidgetControl()
+        VanAligneiOSWidgetLiveActivity()
+    }
+}
@@ -0,0 +1,77 @@
+//
+//  VanAligneiOSWidgetControl.swift
+//  VanAligneiOSWidget
+//
+//  Created by Christopher Helberg on 02.09.26.
+//
+
+import AppIntents
+import SwiftUI
+import WidgetKit
+
+struct VanAligneiOSWidgetControl: ControlWidget {
+    static let kind: String = "fototeddy.VanAligneiOS.VanAligneiOSWidget"
+
+    var body: some ControlWidgetConfiguration {
+        AppIntentControlConfiguration(
+            kind: Self.kind,
+            provider: Provider()
+        ) { value in
+            ControlWidgetToggle(
+                "Start Timer",
+                isOn: value.isRunning,
+                action: StartTimerIntent(value.name)
+            ) { isRunning in
+                Label(isRunning ? "On" : "Off", systemImage: "timer")
+            }
+        }
+        .displayName("Timer")
+        .description("A an example control that runs a timer.")
+    }
+}
+
+extension VanAligneiOSWidgetControl {
+    struct Value {
+        var isRunning: Bool
+        var name: String
+    }
+
+    struct Provider: AppIntentControlValueProvider {
+        func previewValue(configuration: TimerConfiguration) -> Value {
+            VanAligneiOSWidgetControl.Value(isRunning: false, name: configuration.timerName)
+        }
+
+        func currentValue(configuration: TimerConfiguration) async throws -> Value {
+            let isRunning = true // Check if the timer is running
+            return VanAligneiOSWidgetControl.Value(isRunning: isRunning, name: configuration.timerName)
+        }
+    }
+}
+
+struct TimerConfiguration: ControlConfigurationIntent {
+    static let title: LocalizedStringResource = "Timer Name Configuration"
+
+    @Parameter(title: "Timer Name", default: "Timer")
+    var timerName: String
+}
+
+struct StartTimerIntent: SetValueIntent {
+    static let title: LocalizedStringResource = "Start a timer"
+
+    @Parameter(title: "Timer Name")
+    var name: String
+
+    @Parameter(title: "Timer is running")
+    var value: Bool
+
+    init() {}
+
+    init(_ name: String) {
+        self.name = name
+    }
+
+    func perform() async throws -> some IntentResult {
+        // Start the timer…
+        return .result()
+    }
+}
@@ -0,0 +1,288 @@
+//
+//  VanAligneiOSWidgetLiveActivity.swift
+//  VanAligneiOSWidget
+//
+//  Created by Christopher Helberg on 02.09.26.
+//
+
+import ActivityKit
+import WidgetKit
+import SwiftUI
+
+private struct LevelIcon: View {
+    let isLevel: Bool
+    let hasReading: Bool
+
+    var body: some View {
+        Image(systemName: hasReading ? (isLevel ? "checkmark.circle.fill" : "level") : "level")
+            .foregroundStyle(hasReading ? (isLevel ? .green : .orange) : .secondary)
+    }
+}
+
+/// Muss mit `LevelState.levelTolerance` übereinstimmen.
+private let levelTolerance: Double = 0.5
+
+/// Grün bis Toleranz, orange bis 2°, sonst rot – dieselbe Skala für Blase
+/// und Text, wie in der App (`VehicleTilt.colour`). Hier dupliziert, weil
+/// die Extension `Shared/` nicht mitkompiliert (siehe
+/// `LevelActivityAttributes.swift`).
+private func levelColour(forDeviation deviation: Double?) -> Color {
+    guard let deviation else { return .white.opacity(0.4) }
+    if deviation <= levelTolerance { return .green }
+    if deviation <= 2 { return .orange }
+    return .red
+}
+
+/// Verkleinerte Libelle für Sperrbildschirm/CarPlay und die erweiterte
+/// Dynamic Island – dieselbe Optik wie `LevelBubble` in der App, aber ohne
+/// deren Abhängigkeit auf `Shared/Models/LevelState.swift`, das in der
+/// Extension nicht mitkompiliert wird.
+private struct LevelBubbleGlyph: View {
+    let pitch: Double?
+    let roll: Double?
+    let isLevel: Bool
+    var diameter: CGFloat = 54
+
+    /// Bis zu welcher Neigung die Blase ausschlägt, wie in der App-Libelle.
+    private let range: Double = 6
+
+    private var hasReading: Bool { pitch != nil || roll != nil }
+
+    private var bubbleColor: Color {
+        guard let pitch, let roll else { return .white.opacity(0.4) }
+        return levelColour(forDeviation: max(abs(pitch), abs(roll)))
+    }
+
+    var body: some View {
+        let radius = diameter / 2
+        let bubble = diameter * 0.22
+        let travel = radius - bubble / 2 - 3
+        let offsetX = clamped(roll) / range * travel
+        let offsetY = clamped(pitch) / range * travel
+        let toleranceRadius = max(levelTolerance / range * travel, bubble * 0.55)
+
+        ZStack {
+            Circle()
+                .fill(Color.white.opacity(0.1))
+            Circle()
+                .strokeBorder(Color.white.opacity(0.3), lineWidth: 1)
+            Circle()
+                .strokeBorder(isLevel ? Color.green : Color.white.opacity(0.25),
+                              lineWidth: isLevel ? 2 : 1)
+                .frame(width: toleranceRadius * 2, height: toleranceRadius * 2)
+            Circle()
+                .fill(bubbleColor)
+                .frame(width: bubble, height: bubble)
+                // Positiver Pitch heisst: Heck steht höher, die Blase wandert
+                // also nach unten – wie bei der echten Wasserwaage in der App.
+                .offset(x: offsetX, y: offsetY)
+                .opacity(hasReading ? 1 : 0.3)
+        }
+        .frame(width: diameter, height: diameter)
+    }
+
+    private func clamped(_ value: Double?) -> Double {
+        guard let value else { return 0 }
+        return min(max(value, -range), range)
+    }
+}
+
+struct VanAligneiOSWidgetLiveActivity: Widget {
+    var body: some WidgetConfiguration {
+        ActivityConfiguration(for: LevelActivityAttributes.self) { context in
+            LevelActivityContent(attributes: context.attributes, state: context.state)
+                .activityBackgroundTint(Color(white: 0.08))
+                .activitySystemActionForegroundColor(.white)
+
+        } dynamicIsland: { context in
+            // Die Dynamic Island bleibt bewusst so klein wie möglich – Libelle
+            // und Zahlenwerte gehören auf Sperrbildschirm/CarPlay, hier reicht
+            // ein Blick auf Icon und, aufgeklappt, die Kurzanweisung.
+            DynamicIsland {
+                DynamicIslandExpandedRegion(.leading) {
+                    LevelIcon(isLevel: context.state.isLevel, hasReading: context.state.pitch != nil)
+                        .font(.title3)
+                }
+                DynamicIslandExpandedRegion(.bottom) {
+                    Text(context.state.instruction ?? context.attributes.deviceName)
+                        .font(.caption)
+                        .foregroundStyle(context.state.isLevel ? .green : .primary)
+                        .lineLimit(1)
+                }
+            } compactLeading: {
+                LevelIcon(isLevel: context.state.isLevel, hasReading: context.state.pitch != nil)
+            } compactTrailing: {
+                EmptyView()
+            } minimal: {
+                LevelIcon(isLevel: context.state.isLevel, hasReading: context.state.pitch != nil)
+            }
+            .keylineTint(context.state.isLevel ? .green : .orange)
+        }
+        .supplementalActivityFamilies([.small])
+    }
+}
+
+/// Wählt je nach Darstellungsgrösse zwischen Sperrbildschirm- und
+/// Kompaktansicht.
+///
+/// Ohne `.small`-Familie fällt CarPlay (wie die Smart Stack der Uhr) auf
+/// `compactLeading`/`compactTrailing` der Dynamic Island zurück – dort steht
+/// nur das generische Symbol und, weil `compactTrailing` leer bleibt, gar
+/// kein Text. Erst die `.small`-Familie liefert CarPlay Libelle und Text.
+private struct LevelActivityContent: View {
+    let attributes: LevelActivityAttributes
+    let state: LevelActivityAttributes.ContentState
+
+    @Environment(\.activityFamily) private var activityFamily
+
+    var body: some View {
+        switch activityFamily {
+        case .small:
+            CompactLevelView(attributes: attributes, state: state)
+        default:
+            LockScreenLevelView(attributes: attributes, state: state)
+        }
+    }
+}
+
+/// Kompaktform für CarPlay-Dashboard und Smart Stack der Uhr: Libelle plus
+/// ein Blick-Symbol statt eines ganzen Satzes – zum Lesen im Vorbeifahren.
+///
+/// Gezeigt wird nur, welche Seite höher steht: Buchstabe (Längsneigung),
+/// Pfeil, Buchstabe (Querneigung) – z.B. "H ↑ L" für "Heck und links stehen
+/// höher". Ein einzelner Pfeil in der Mitte reicht, weil ohnehin nur die
+/// höher stehende Seite benannt wird ("höher" ist implizit "nach oben").
+private struct CompactLevelView: View {
+    let attributes: LevelActivityAttributes
+    let state: LevelActivityAttributes.ContentState
+
+    private var hasReading: Bool { state.pitch != nil || state.roll != nil }
+
+    /// "H"/"F", nur wenn ausserhalb der Toleranz.
+    private var pitchLetter: String? {
+        guard let pitch = state.pitch, abs(pitch) > levelTolerance else { return nil }
+        return pitch >= 0 ? "H" : "F"
+    }
+
+    /// "R"/"L", nur wenn ausserhalb der Toleranz.
+    private var rollLetter: String? {
+        guard let roll = state.roll, abs(roll) > levelTolerance else { return nil }
+        return roll >= 0 ? "R" : "L"
+    }
+
+    /// Dieselbe Skala wie die Blase, über die grössere der beiden Neigungen.
+    private var statusColor: Color {
+        guard let pitch = state.pitch, let roll = state.roll else { return .white.opacity(0.4) }
+        return levelColour(forDeviation: max(abs(pitch), abs(roll)))
+    }
+
+    var body: some View {
+        HStack(spacing: 14) {
+            LevelBubbleGlyph(pitch: state.pitch, roll: state.roll, isLevel: state.isLevel, diameter: 40)
+
+            Group {
+                if !hasReading {
+                    Text("–")
+                } else if state.isLevel {
+                    Image(systemName: "checkmark.circle.fill")
+                } else {
+                    HStack(spacing: 6) {
+                        if let pitchLetter { Text(pitchLetter) }
+                        Image(systemName: "arrow.up")
+                        if let rollLetter { Text(rollLetter) }
+                    }
+                }
+            }
+            // Skalierbarer Textstil statt fester Punktgrösse: CarPlay-
+            // Bildschirme unterscheiden sich in Grösse, die exakten Masse
+            // eines Displays sind aber nicht abfragbar. `minimumScaleFactor`
+            // lässt die Schrift so gross wie möglich, aber so klein wie
+            // nötig werden, um in den vom System zugeteilten Platz zu passen.
+            .font(.title2.weight(.bold))
+            .minimumScaleFactor(0.5)
+            .lineLimit(1)
+            .foregroundStyle(statusColor)
+
+            Spacer(minLength: 0)
+        }
+        .padding(.horizontal, 12)
+        .padding(.vertical, 8)
+    }
+}
+
+/// Sperrbildschirm- und Banner-Ansicht.
+private struct LockScreenLevelView: View {
+    let attributes: LevelActivityAttributes
+    let state: LevelActivityAttributes.ContentState
+
+    /// Längszeile, z.B. "Heck steht höher 1.8°" – nur wenn ausserhalb der
+    /// Toleranz, genau wie bei `LevelState.instruction` in der App.
+    private var pitchLine: String? {
+        guard let pitch = state.pitch, abs(pitch) > levelTolerance else { return nil }
+        let label = pitch >= 0 ? "Heck steht höher" : "Front steht höher"
+        return "\(label) \(LevelDirectionFormatting.magnitude(pitch))"
+    }
+
+    /// Querzeile, z.B. "links steht höher 0.9°".
+    private var rollLine: String? {
+        guard let roll = state.roll, abs(roll) > levelTolerance else { return nil }
+        let label = roll >= 0 ? "rechts steht höher" : "links steht höher"
+        return "\(label) \(LevelDirectionFormatting.magnitude(roll))"
+    }
+
+    var body: some View {
+        HStack(spacing: 20) {
+            LevelBubbleGlyph(pitch: state.pitch, roll: state.roll, isLevel: state.isLevel, diameter: 64)
+
+            VStack(alignment: .leading, spacing: 6) {
+                Text(attributes.deviceName)
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+
+                if pitchLine == nil && rollLine == nil {
+                    Text(state.pitch == nil && state.roll == nil ? "Keine Messwerte" : "Steht eben")
+                        .font(.title3.weight(.semibold))
+                        .foregroundStyle(state.isLevel ? .green : .white)
+                } else {
+                    if let pitchLine {
+                        Text(pitchLine).font(.title3.weight(.semibold))
+                    }
+                    if let rollLine {
+                        Text(rollLine).font(.title3.weight(.semibold))
+                    }
+                }
+            }
+
+            Spacer(minLength: 0)
+        }
+        .padding(16)
+        .foregroundStyle(.white)
+    }
+}
+
+extension LevelActivityAttributes {
+    fileprivate static var preview: LevelActivityAttributes {
+        LevelActivityAttributes(deviceName: "Nivellierung")
+    }
+}
+
+extension LevelActivityAttributes.ContentState {
+    fileprivate static var level: LevelActivityAttributes.ContentState {
+        LevelActivityAttributes.ContentState(pitch: 0.1, roll: -0.2, isLevel: true,
+                                              instruction: "Steht eben", isCalibrated: true,
+                                              updatedAt: .now)
+    }
+
+    fileprivate static var tilted: LevelActivityAttributes.ContentState {
+        LevelActivityAttributes.ContentState(pitch: 2.4, roll: -1.1, isLevel: false,
+                                              instruction: "Heck steht höher, links steht höher",
+                                              isCalibrated: true, updatedAt: .now)
+    }
+}
+
+#Preview("Notification", as: .content, using: LevelActivityAttributes.preview) {
+   VanAligneiOSWidgetLiveActivity()
+} contentStates: {
+    LevelActivityAttributes.ContentState.level
+    LevelActivityAttributes.ContentState.tilted
+}