Controller redesign with automation runs and room history

Sources/Controller/App/AppFeature.swift

@@ -24,10 +24,10 @@ struct AppFeature: Sendable {
 
     @ObservableState
     struct State: Equatable, Sendable {
-        var selectedTab: Tab = .automations
+        var selectedTab: Tab = .overview
+        var overview = OverviewFeature.State()
         var automations = AutomationsFeature.State()
-        var actions = ActionsFeature.State()
-        var history = HistoryFeature.State()
+        var rooms = RoomsFeature.State()
         var settings = SettingsFeature.State()
 
         var openWindowsCount: Int? {
@@ -38,25 +38,25 @@ struct AppFeature: Sendable {
     // MARK: - Tab
 
     enum Tab: Sendable, Equatable, CaseIterable {
+        case overview
         case automations
-        case actions
-        case history
+        case rooms
         case settings
 
         var title: String {
             switch self {
+            case .overview: return "Overview"
             case .automations: return "Automations"
-            case .actions: return "Actions"
-            case .history: return "History"
+            case .rooms: return "Rooms"
             case .settings: return "Settings"
             }
         }
 
         var systemImage: String {
             switch self {
+            case .overview: return "house"
             case .automations: return "lamp.floor"
-            case .actions: return "list.bullet.clipboard"
-            case .history: return "chart.line.uptrend.xyaxis"
+            case .rooms: return "square.grid.2x2"
             case .settings: return "gear"
             }
         }
@@ -66,9 +66,9 @@ struct AppFeature: Sendable {
 
     enum Action: Sendable, BindableAction {
         case selectedTabChanged(Tab)
+        case overview(OverviewFeature.Action)
         case automations(AutomationsFeature.Action)
-        case actions(ActionsFeature.Action)
-        case history(HistoryFeature.Action)
+        case rooms(RoomsFeature.Action)
         case settings(SettingsFeature.Action)
 
         // Live Activities & Push Notifications
@@ -82,6 +82,7 @@ struct AppFeature: Sendable {
 
         // Scene phase changes
         case scenePhaseChanged(old: ScenePhase, new: ScenePhase)
+        case refreshAll
 
         case binding(BindingAction<State>)
     }
@@ -97,19 +98,19 @@ struct AppFeature: Sendable {
     var body: some ReducerOf<Self> {
         BindingReducer()
 
-        Scope(state: \.automations, action: \.automations) {
-            AutomationsFeature()
+        Scope(\.overview, action: \.overview) {
+            OverviewFeature()
         }
 
-        Scope(state: \.actions, action: \.actions) {
-            ActionsFeature()
+        Scope(\.automations, action: \.automations) {
+            AutomationsFeature()
         }
 
-        Scope(state: \.history, action: \.history) {
-            HistoryFeature()
+        Scope(\.rooms, action: \.rooms) {
+            RoomsFeature()
         }
 
-        Scope(state: \.settings, action: \.settings) {
+        Scope(\.settings, action: \.settings) {
             SettingsFeature()
         }
 
@@ -119,13 +120,17 @@ struct AppFeature: Sendable {
                 state.selectedTab = tab
                 return .none
 
-            case .automations:
+            case let .overview(.delegate(.openAutomation(name))):
+                state.selectedTab = .automations
+                return .send(.automations(.openAutomation(name)))
+
+            case .overview:
                 return .none
 
-            case .actions:
+            case .automations:
                 return .none
 
-            case .history:
+            case .rooms:
                 return .none
 
             case .settings:
@@ -201,11 +206,13 @@ struct AppFeature: Sendable {
                     return .none
                 }
 
-                // Refresh all tabs and start monitoring when app becomes active
+                return .send(.refreshAll)
+
+            case .refreshAll:
                 return .merge(
+                    .send(.overview(.refresh)),
                     .send(.automations(.refresh)),
-                    .send(.actions(.refresh)),
-                    .send(.history(.refresh)),
+                    .send(.rooms(.refresh)),
                     .send(.refreshWindowStates),
                     .send(.startMonitoringLiveActivities),
                     .send(.clearDeliveredNotifications)
@@ -224,42 +231,33 @@ struct AppView: View {
     var body: some View {
         TabView(selection: $store.selectedTab) {
             Tab(
-                AppFeature.Tab.automations.title,
-                systemImage: AppFeature.Tab.automations.systemImage,
-                value: AppFeature.Tab.automations
+                AppFeature.Tab.overview.title,
+                systemImage: AppFeature.Tab.overview.systemImage,
+                value: AppFeature.Tab.overview
             ) {
-                AutomationsView(
-                    store: store.scope(
-                        state: \.automations,
-                        action: \.automations
-                    )
+                OverviewView(
+                    store: store.scope(\.overview, action: \.overview),
+                    openWindows: store.settings.windowContentState?.windowStates ?? []
                 )
             }
+            .badge(store.openWindowsCount ?? 0)
 
             Tab(
-                AppFeature.Tab.actions.title,
-                systemImage: AppFeature.Tab.actions.systemImage,
-                value: AppFeature.Tab.actions
+                AppFeature.Tab.automations.title,
+                systemImage: AppFeature.Tab.automations.systemImage,
+                value: AppFeature.Tab.automations
             ) {
-                ActionsView(
-                    store: store.scope(
-                        state: \.actions,
-                        action: \.actions
-                    )
+                AutomationsView(
+                    store: store.scope(\.automations, action: \.automations)
                 )
             }
 
             Tab(
-                AppFeature.Tab.history.title,
-                systemImage: AppFeature.Tab.history.systemImage,
-                value: AppFeature.Tab.history
+                AppFeature.Tab.rooms.title,
+                systemImage: AppFeature.Tab.rooms.systemImage,
+                value: AppFeature.Tab.rooms
             ) {
-                HistoryView(
-                    store: store.scope(
-                        state: \.history,
-                        action: \.history
-                    )
-                )
+                RoomsView(store: store.scope(\.rooms, action: \.rooms))
             }
 
             Tab(
@@ -268,15 +266,10 @@ struct AppView: View {
                 value: AppFeature.Tab.settings
             ) {
                 SettingsView(
-                    store: store.scope(
-                        state: \.settings,
-                        action: \.settings
-                    )
+                    store: store.scope(\.settings, action: \.settings)
                 )
             }
-            .badge(store.openWindowsCount ?? 0)
         }
-        .tabViewStyle(.sidebarAdaptable)
         .onSceneChange { oldPhase, newPhase in
             store.send(.scenePhaseChanged(old: oldPhase, new: newPhase))
         }

Sources/Controller/Charts/ChartPalette.swift

@@ -0,0 +1,36 @@
+//
+//  ChartPalette.swift
+//  Controller
+//
+
+import HAModels
+import SwiftUI
+
+/// Chart colors follow the device type, never the series order, so a lamp is green in every chart.
+enum ChartPalette {
+    static func color(for type: CharacteristicsType) -> Color {
+        switch type {
+        case .switcher, .brightness, .colorTemperature, .color:
+            return .green
+        case .motionSensor:
+            return .blue
+        case .contactSensor:
+            return .orange
+        case .lightSensor:
+            return .indigo
+        case .carbonDioxideSensorId:
+            return .teal
+        default:
+            return .gray
+        }
+    }
+
+    static let night = Color.gray.opacity(0.15)
+
+    /// Times for a day or less, weekdays beyond that; a week of "00:00" labels says nothing.
+    static func axisFormat(for domain: ClosedRange<Date>) -> Date.FormatStyle {
+        domain.upperBound.timeIntervalSince(domain.lowerBound) > 86_400 * 1.5
+            ? .dateTime.weekday(.abbreviated)
+            : .dateTime.hour().minute()
+    }
+}

Sources/Controller/Charts/DailyBarChart.swift

@@ -0,0 +1,48 @@
+//
+//  DailyBarChart.swift
+//  Controller
+//
+
+import Charts
+import SwiftUI
+
+/// One bar per day, with an optional point per day (e.g. the mean on top of the maximum).
+struct DailyBarChart: View {
+    let bars: [(day: Date, value: Double)]
+    let color: Color
+    let unit: String
+    var points: [(day: Date, value: Double)] = []
+    var barLabel = "Total"
+    var pointLabel = "Mean"
+
+    var body: some View {
+        Chart {
+            ForEach(bars.indices, id: \.self) { index in
+                BarMark(x: .value("Day", bars[index].day, unit: .day), y: .value(unit, bars[index].value))
+                    .foregroundStyle(by: .value("Series", barLabel))
+            }
+            ForEach(points.indices, id: \.self) { index in
+                PointMark(x: .value("Day", points[index].day, unit: .day), y: .value(unit, points[index].value))
+                    .foregroundStyle(by: .value("Series", pointLabel))
+            }
+        }
+        .chartYAxisLabel(unit)
+        .chartForegroundStyleScale([barLabel: color, pointLabel: Color.primary])
+        .chartLegend(points.isEmpty ? .hidden : .visible)
+        .chartXAxis {
+            AxisMarks(values: .stride(by: .day)) { _ in
+                AxisValueLabel(format: .dateTime.weekday(.abbreviated), centered: true)
+            }
+        }
+        .frame(height: 140)
+    }
+}
+
+#Preview {
+    DailyBarChart(
+        bars: (0..<7).map { (Date().addingTimeInterval(Double($0 - 6) * 86_400), Double($0 * 10)) },
+        color: .orange,
+        unit: "min"
+    )
+    .padding()
+}

Sources/Controller/Charts/TimelineChart.swift

@@ -0,0 +1,79 @@
+//
+//  TimelineChart.swift
+//  Controller
+//
+
+import Charts
+import SwiftUI
+
+/// State lanes (lamp on, motion, window open, …) over a shared time axis.
+struct TimelineChart: View {
+    struct Lane: Identifiable {
+        let label: String
+        let color: Color
+        let intervals: [DateInterval]
+        /// Legend entry; lanes without one keep the chart legend hidden.
+        var kind: String?
+        var id: String { label }
+    }
+
+    let lanes: [Lane]
+    let domain: ClosedRange<Date>
+    var nights: [DateInterval] = []
+
+    var body: some View {
+        // Seconds-long motion pulses would vanish on a 24 h axis; keep each bar visible.
+        let minimumDuration = domain.upperBound.timeIntervalSince(domain.lowerBound) / 250
+        Chart {
+            ForEach(nights, id: \.start) { night in
+                RectangleMark(xStart: .value("Start", night.start), xEnd: .value("End", night.end))
+                    .foregroundStyle(ChartPalette.night)
+            }
+            ForEach(lanes) { lane in
+                ForEach(lane.intervals, id: \.start) { interval in
+                    RectangleMark(
+                        xStart: .value("Start", interval.start),
+                        xEnd: .value("End", max(interval.end, interval.start.addingTimeInterval(minimumDuration))),
+                        y: .value("Lane", lane.label),
+                        height: .fixed(12)
+                    )
+                    .foregroundStyle(by: .value("Kind", lane.kind ?? lane.label))
+                    .clipShape(.rect(cornerRadius: 3))
+                }
+            }
+        }
+        .chartXScale(domain: domain)
+        .chartYScale(domain: lanes.map(\.label))
+        .chartForegroundStyleScale(domain: legendEntries.map(\.kind), range: legendEntries.map(\.color))
+        .chartLegend(lanes.contains { $0.kind != nil } ? .visible : .hidden)
+        .chartPlotStyle { $0.clipped() }
+        .chartXAxis {
+            // .aligned keeps the last time label inside the plot instead of clipping it.
+            AxisMarks(preset: .aligned) { _ in
+                AxisGridLine()
+                AxisValueLabel(format: ChartPalette.axisFormat(for: domain))
+            }
+        }
+        .frame(height: CGFloat(lanes.count) * 30 + (lanes.contains { $0.kind != nil } ? 54 : 30))
+    }
+
+    private var legendEntries: [(kind: String, color: Color)] {
+        var seen = Set<String>()
+        return lanes.compactMap { lane in
+            let kind = lane.kind ?? lane.label
+            return seen.insert(kind).inserted ? (kind, lane.color) : nil
+        }
+    }
+}
+
+#Preview {
+    let now = Date()
+    TimelineChart(
+        lanes: [
+            .init(label: "Worklight", color: .green, intervals: [DateInterval(start: now.addingTimeInterval(-7_200), end: now.addingTimeInterval(-3_600))]),
+            .init(label: "Window", color: .orange, intervals: [DateInterval(start: now.addingTimeInterval(-600), duration: 60)])
+        ],
+        domain: now.addingTimeInterval(-86_400)...now
+    )
+    .padding()
+}