Refine charge record flow and charged device editing · f411278

Refine charge record flow and charged device editing
Browse files

bogdan committed a month ago

codex/restore-session-chart main

1 parent 45253c1

commit f411278

Showing 5 changed files with 472 additions and 222 deletions

+106 -11

USB Meter/Model/AppData.swift

@@ -42,6 +42,7 @@ final class AppData : ObservableObject {
     private var chargeInsightsStoreObserver: AnyCancellable?
     private var chargeInsightsRemoteObserver: AnyCancellable?
     private var chargerStandbyPowerStoreObserver: AnyCancellable?
+    private var pendingChargedDevicesReloadWorkItem: DispatchWorkItem?
     private let meterStore = MeterNameStore.shared
     private var chargeInsightsStore: ChargeInsightsStore?
     private let chargerStandbyPowerStore = ChargerStandbyPowerStore()
@@ -103,7 +104,7 @@ final class AppData : ObservableObject {
         )
         .receive(on: DispatchQueue.main)
         .sink { [weak self] _ in
-            self?.reloadChargedDevices()
+            self?.scheduleChargedDevicesReload()
         }
 
         chargeInsightsRemoteObserver = NotificationCenter.default.publisher(
@@ -112,7 +113,7 @@ final class AppData : ObservableObject {
         )
         .receive(on: DispatchQueue.main)
         .sink { [weak self] _ in
-            self?.reloadChargedDevices()
+            self?.scheduleChargedDevicesReload()
         }
 
         chargeNotificationCoordinator.ensureAuthorizationIfNeeded()
@@ -194,7 +195,7 @@ final class AppData : ObservableObject {
     func currentChargedDeviceSummary(for meterMACAddress: String) -> ChargedDeviceSummary? {
         let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
 
-        if let activeSession = activeChargeSessionSummary(for: normalizedMAC),
+        if let activeSession = cachedActiveChargeSessionSummary(for: normalizedMAC),
            let liveDevice = chargedDevices.first(where: {
                $0.id == activeSession.chargedDeviceID && $0.isCharger == false
            }) {
@@ -209,7 +210,7 @@ final class AppData : ObservableObject {
     func currentChargerSummary(for meterMACAddress: String) -> ChargedDeviceSummary? {
         let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
 
-        if let activeSession = activeChargeSessionSummary(for: normalizedMAC),
+        if let activeSession = cachedActiveChargeSessionSummary(for: normalizedMAC),
            let chargerID = activeSession.chargerID,
            let liveCharger = chargedDevices.first(where: {
                $0.id == chargerID && $0.isCharger
@@ -223,7 +224,10 @@ final class AppData : ObservableObject {
     }
 
     func activeChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {
-        chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: meterMACAddress)
+        if let cachedSummary = cachedActiveChargeSessionSummary(for: meterMACAddress) {
+            return cachedSummary
+        }
+        return chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: meterMACAddress)
     }
 
     func chargerStandbyMeasurementSession(for meterMACAddress: String) -> ChargerStandbyPowerMonitorSession? {
@@ -557,14 +561,42 @@ final class AppData : ObservableObject {
         return didSave
     }
 
+    @discardableResult
+    func addBatteryCheckpoint(
+        percent: Double,
+        label: String?,
+        for sessionID: UUID,
+        measuredEnergyWh: Double?,
+        measuredChargeAh: Double?
+    ) -> Bool {
+        let didSave = chargeInsightsStore?.addBatteryCheckpoint(
+            percent: percent,
+            label: label,
+            for: sessionID,
+            measuredEnergyWh: measuredEnergyWh,
+            measuredChargeAh: measuredChargeAh
+        ) ?? false
+
+        if didSave {
+            reloadChargedDevices()
+        }
+
+        return didSave
+    }
+
     func batteryCheckpointPlausibilityWarning(
         percent: Double,
-        for sessionID: UUID
+        for sessionID: UUID,
+        effectiveEnergyWhOverride: Double? = nil
     ) -> BatteryCheckpointPlausibilityWarning? {
         guard let session = chargeSessionSummary(id: sessionID) else {
             return nil
         }
-        return batteryCheckpointPlausibilityWarning(percent: percent, for: session)
+        return batteryCheckpointPlausibilityWarning(
+            percent: percent,
+            for: session,
+            effectiveEnergyWhOverride: effectiveEnergyWhOverride
+        )
     }
 
     @discardableResult
@@ -575,7 +607,7 @@ final class AppData : ObservableObject {
         ) ?? false
 
         if didDelete {
-            reloadChargedDevices()
+            scheduleChargedDevicesReload(delay: 0)
         }
 
         return didDelete
@@ -756,7 +788,32 @@ final class AppData : ObservableObject {
         }
     }
 
+    private func scheduleChargedDevicesReload(delay: TimeInterval = 0.15) {
+        pendingChargedDevicesReloadWorkItem?.cancel()
+
+        let workItem = DispatchWorkItem { [weak self] in
+            self?.reloadChargedDevices()
+        }
+        pendingChargedDevicesReloadWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)
+    }
+
+    private func cachedActiveChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {
+        let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)
+        guard !normalizedMAC.isEmpty else {
+            return nil
+        }
+
+        return chargedDevices
+            .lazy
+            .compactMap(\.activeSession)
+            .first(where: { $0.status == .active && $0.meterMACAddress == normalizedMAC })
+    }
+
     private func reloadChargedDevices() {
+        pendingChargedDevicesReloadWorkItem?.cancel()
+        pendingChargedDevicesReloadWorkItem = nil
+
         let standbyMeasurementsByChargerID = chargerStandbyPowerStore.measurementsByChargerID()
         chargedDevices = (chargeInsightsStore?.fetchChargedDeviceSummaries() ?? []).map { chargedDevice in
             chargedDevice.withStandbyPowerMeasurements(
@@ -823,7 +880,8 @@ final class AppData : ObservableObject {
 
     private func batteryCheckpointPlausibilityWarning(
         percent: Double,
-        for session: ChargeSessionSummary
+        for session: ChargeSessionSummary,
+        effectiveEnergyWhOverride: Double? = nil
     ) -> BatteryCheckpointPlausibilityWarning? {
         guard percent.isFinite, percent >= 0, percent <= 100 else {
             return nil
@@ -847,8 +905,46 @@ final class AppData : ObservableObject {
             )
         }
 
+        let effectiveEnergyWh = effectiveEnergyWhOverride
+            ?? session.effectiveBatteryEnergyWh
+            ?? session.measuredEnergyWh
+
+        if let lastCheckpoint = sortedCheckpoints.last,
+           let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID) {
+            let estimatedCapacityWh = session.capacityEstimateWh
+                ?? chargedDevice.estimatedBatteryCapacityWh(for: session.chargingTransportMode)
+                ?? chargedDevice.estimatedBatteryCapacityWh
+
+            if let estimatedCapacityWh, estimatedCapacityWh > 0 {
+                let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)
+                let expectedPercent = min(
+                    100,
+                    max(
+                        lastCheckpoint.batteryPercent,
+                        lastCheckpoint.batteryPercent + (energyDeltaWh / estimatedCapacityWh) * 100
+                    )
+                )
+                let predictionGap = percent - expectedPercent
+                guard abs(predictionGap) >= 4 else {
+                    return nil
+                }
+
+                let direction = predictionGap > 0 ? "above" : "below"
+                let gapText = abs(predictionGap).format(decimalDigits: 0)
+                let expectedText = expectedPercent.format(decimalDigits: 0)
+
+                return BatteryCheckpointPlausibilityWarning(
+                    title: "Checkpoint Looks Implausible",
+                    message: "The last checkpoint stored \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))% at \(lastCheckpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh. The current counted energy is \(effectiveEnergyWh.format(decimalDigits: 2)) Wh, which supports about \(expectedText)% based on \(estimatedCapacityWh.format(decimalDigits: 2)) Wh capacity. The entered value is about \(gapText) percentage points \(direction) that."
+                )
+            }
+        }
+
         guard let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID),
-              let prediction = chargedDevice.batteryLevelPrediction(for: session)
+              let prediction = chargedDevice.batteryLevelPrediction(
+                for: session,
+                effectiveEnergyWhOverride: effectiveEnergyWh
+              )
         else {
             return nil
         }
@@ -863,7 +959,6 @@ final class AppData : ObservableObject {
         let predictedText = prediction.predictedPercent.format(decimalDigits: 0)
 
         if let lastCheckpoint = sortedCheckpoints.last {
-            let effectiveEnergyWh = session.effectiveBatteryEnergyWh ?? session.measuredEnergyWh
             let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)
             return BatteryCheckpointPlausibilityWarning(
                 title: "Checkpoint Looks Implausible",


+92 -11

USB Meter/Model/ChargeInsightsStore.swift

View

@@ -581,7 +581,9 @@ final class ChargeInsightsStore {
     func addBatteryCheckpoint(
         percent: Double,
         label: String?,
-        for sessionID: UUID
+        for sessionID: UUID,
+        measuredEnergyWh: Double? = nil,
+        measuredChargeAh: Double? = nil
     ) -> Bool {
         guard percent.isFinite, percent >= 0, percent <= 100 else {
             return false
@@ -593,7 +595,13 @@ final class ChargeInsightsStore {
                 return
             }
 
-            didSave = addBatteryCheckpoint(percent: percent, label: label, to: session)
+            didSave = addBatteryCheckpoint(
+                percent: percent,
+                label: label,
+                measuredEnergyWh: measuredEnergyWh,
+                measuredChargeAh: measuredChargeAh,
+                to: session
+            )
         }
         return didSave
     }
@@ -617,16 +625,11 @@ final class ChargeInsightsStore {
             context.delete(checkpoint)
             refreshCheckpointDerivedValues(for: session)
 
-            guard saveContext() else {
-                return
-            }
-
             if let chargedDeviceID {
                 refreshDerivedMetrics(forChargedDeviceID: chargedDeviceID)
-                didSave = saveContext()
-            } else {
-                didSave = true
             }
+
+            didSave = saveContext()
         }
         return didSave
     }
@@ -856,12 +859,18 @@ final class ChargeInsightsStore {
             let devices = fetchObjects(entityName: EntityName.chargedDevice)
             let sessions = fetchObjects(entityName: EntityName.chargeSession)
             let checkpoints = fetchObjects(entityName: EntityName.chargeCheckpoint)
-            let sessionSamples = fetchObjects(entityName: EntityName.chargeSessionSample)
 
             let checkpointsBySessionID = Dictionary(grouping: checkpoints) { stringValue($0, key: "sessionID") ?? "" }
-            let samplesBySessionID = Dictionary(grouping: sessionSamples) { stringValue($0, key: "sessionID") ?? "" }
             let sessionsByDeviceID = Dictionary(grouping: sessions) { stringValue($0, key: "chargedDeviceID") ?? "" }
             let sessionsByChargerID = Dictionary(grouping: sessions) { stringValue($0, key: "chargerID") ?? "" }
+            let sampleBackedSessionIDs = sampleBackedSessionIDs(
+                devices: devices,
+                sessionsByDeviceID: sessionsByDeviceID,
+                sessionsByChargerID: sessionsByChargerID
+            )
+            let samplesBySessionID = Dictionary(
+                grouping: fetchSessionSampleObjects(forSessionIDs: Array(sampleBackedSessionIDs))
+            ) { stringValue($0, key: "sessionID") ?? "" }
 
             summaries = devices.compactMap { device in
                 guard
@@ -2111,6 +2120,16 @@ final class ChargeInsightsStore {
         return (try? context.fetch(request)) ?? []
     }
 
+    private func fetchSessionSampleObjects(forSessionIDs sessionIDs: [String]) -> [NSManagedObject] {
+        guard !sessionIDs.isEmpty else {
+            return []
+        }
+
+        let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargeSessionSample)
+        request.predicate = NSPredicate(format: "sessionID IN %@", sessionIDs)
+        return (try? context.fetch(request)) ?? []
+    }
+
     private func fetchCheckpointObject(id: String, sessionID: String) -> NSManagedObject? {
         let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargeCheckpoint)
         request.predicate = NSPredicate(format: "id == %@ AND sessionID == %@", id, sessionID)
@@ -2139,6 +2158,68 @@ final class ChargeInsightsStore {
         return (try? context.fetch(request)) ?? []
     }
 
+    private func sampleBackedSessionIDs(
+        devices: [NSManagedObject],
+        sessionsByDeviceID: [String: [NSManagedObject]],
+        sessionsByChargerID: [String: [NSManagedObject]]
+    ) -> Set<String> {
+        var sessionIDs: Set<String> = []
+
+        for device in devices {
+            guard
+                let deviceID = stringValue(device, key: "id"),
+                let rawClass = stringValue(device, key: "deviceClassRawValue"),
+                let deviceClass = ChargedDeviceClass(rawValue: rawClass)
+            else {
+                continue
+            }
+
+            let relevantSessions = relevantSessionObjects(
+                for: deviceID,
+                deviceClass: deviceClass,
+                sessionsByDeviceID: sessionsByDeviceID,
+                sessionsByChargerID: sessionsByChargerID
+            )
+            .sorted { lhs, rhs in
+                let lhsStatus = statusValue(lhs, key: "statusRawValue") ?? .completed
+                let rhsStatus = statusValue(rhs, key: "statusRawValue") ?? .completed
+
+                if lhsStatus.isOpen && !rhsStatus.isOpen {
+                    return true
+                }
+                if !lhsStatus.isOpen && rhsStatus.isOpen {
+                    return false
+                }
+
+                return (dateValue(lhs, key: "startedAt") ?? .distantPast)
+                    > (dateValue(rhs, key: "startedAt") ?? .distantPast)
+            }
+
+            var recentCompletedSamplesIncluded = 0
+
+            for session in relevantSessions {
+                guard let sessionID = stringValue(session, key: "id"),
+                      let status = statusValue(session, key: "statusRawValue") else {
+                    continue
+                }
+
+                if status.isOpen {
+                    sessionIDs.insert(sessionID)
+                    continue
+                }
+
+                guard recentCompletedSamplesIncluded < 2 else {
+                    continue
+                }
+
+                sessionIDs.insert(sessionID)
+                recentCompletedSamplesIncluded += 1
+            }
+        }
+
+        return sessionIDs
+    }
+
     private func relevantSessionObjects(
         for chargedDeviceID: String,
         deviceClass: ChargedDeviceClass,


+134 -64

USB Meter/Views/ChargedDevices/BatteryCheckpointEditorSheetView.swift

View

+                     import SwiftUI
+                    -struct BatteryCheckpointEditorSheetView: View {
+                    +struct BatteryCheckpointEditorContentView: View {
+                         @EnvironmentObject private var appData: AppData
+                    -    @EnvironmentObject private var meter: Meter
+                    -    @Environment(\.dismiss) private var dismiss
+                    +    let sessionID: UUID
+                    +    let message: String
+                    +    let effectiveEnergyWhOverride: Double?
+                    +    let measuredChargeAhOverride: Double?
+                    +    let onCancel: (() -> Void)?
+                    +    let onSaved: (() -> Void)?
+                         @State private var batteryPercent = ""
+                         @State private var label = ""
+                    -    @State private var confirmationWarning: BatteryCheckpointPlausibilityWarning?
+                    -    private var activeSession: ChargeSessionSummary? {
+                    -        appData.activeChargeSessionSummary(for: meter.btSerial.macAddress.description)
+                    -    }
+                    +    @State private var showsWarningPopover = false
+                         private var plausibilityWarning: BatteryCheckpointPlausibilityWarning? {
+                    -        guard let percent = Double(batteryPercent),
+                    -              let activeSession else {
+                    +        guard let percent = normalizedBatteryPercent else {
+                                 return nil
+                    -        return appData.batteryCheckpointPlausibilityWarning(percent: percent, for: activeSession.id)
+                    +        return appData.batteryCheckpointPlausibilityWarning(
+                    +            percent: percent,
+                    +            for: sessionID,
+                    +            effectiveEnergyWhOverride: effectiveEnergyWhOverride
+                    +        )
+                    -    var body: some View {
+                    -        NavigationView {
+                    -            Form {
+                    -                Section(
+                    -                    header: ContextInfoHeader(
+                    -                        title: "Checkpoint",
+                    -                        message: "The checkpoint is stored on the active charge session and later used for capacity estimation and the typical charge curve."
+                    -                    )
+                    -                ) {
+                    -                    TextField("Battery %", text: $batteryPercent)
+                    -                        .keyboardType(.decimalPad)
+                    -                    TextField("Label (optional)", text: $label)
+                    -                }
+                    +    private var normalizedBatteryPercent: Double? {
+                    +        let normalized = batteryPercent
+                    +            .trimmingCharacters(in: .whitespacesAndNewlines)
+                    +            .replacingOccurrences(of: ",", with: ".")
+                    +        return Double(normalized)
+                    +    }
+                    +    private var canSave: Bool {
+                    +        guard let percent = normalizedBatteryPercent else {
+                    +            return false
+                    +        }
+                    +        return percent >= 0 && percent <= 100
+                    +    }
+                    +    var body: some View {
+                    +        VStack(alignment: .leading, spacing: 12) {
+                    +            HStack(spacing: 8) {
+                    +                Text("Checkpoint")
+                    +                Spacer(minLength: 0)
+                                     if let plausibilityWarning {
+                    -                    Section(header: Text(plausibilityWarning.title)) {
+                    -                        Text(plausibilityWarning.message)
+                    -                            .font(.footnote)
+                    +                    Button {
+                    +                        showsWarningPopover.toggle()
+                    +                    } label: {
+                    +                        Image(systemName: "exclamationmark.triangle.fill")
+                    +                            .font(.body.weight(.semibold))
+                                                 .foregroundColor(.orange)
+                    +                    .buttonStyle(.plain)
+                    +                    .accessibilityLabel(plausibilityWarning.title)
+                    +                    .popover(isPresented: $showsWarningPopover, arrowEdge: .top) {
+                    +                        VStack(alignment: .leading, spacing: 10) {
+                    +                            Text(plausibilityWarning.title)
+                    +                                .font(.headline)
+                    +                            Text(plausibilityWarning.message)
+                    +                                .font(.body)
+                    +                                .fixedSize(horizontal: false, vertical: true)
+                    +                        }
+                    +                        .padding(16)
+                    +                        .frame(width: 320, alignment: .leading)
+                    +                    }
+                    +                ContextInfoButton(
+                    +                    title: "Checkpoint",
+                    +                    message: message
+                    +                )
+                    -            .navigationTitle("Battery Checkpoint")
+                    -            .navigationBarTitleDisplayMode(.inline)
+                    -            .toolbar {
+                    -                ToolbarItem(placement: .cancellationAction) {
+                    +            VStack(alignment: .leading, spacing: 10) {
+                    +                TextField("Battery %", text: $batteryPercent)
+                    +                    .keyboardType(.decimalPad)
+                    +                    .textFieldStyle(.roundedBorder)
+                    +                TextField("Label (optional)", text: $label)
+                    +                    .textFieldStyle(.roundedBorder)
+                    +            }
+                    +            HStack(spacing: 10) {
+                    +                if let onCancel {
+                                         Button("Cancel") {
+                    -                        dismiss()
+                    +                        onCancel()
+                    +                    .frame(maxWidth: .infinity)
+                    +                    .padding(.vertical, 10)
+                    +                    .meterCard(tint: .secondary, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 14)
+                    +                    .buttonStyle(.plain)
+                    -                ToolbarItem(placement: .confirmationAction) {
+                    -                    Button("Save") {
+                    -                        saveCheckpoint()
+                    -                    }
+                    -                    .disabled(
+                    -                        (Double(batteryPercent) ?? -1) < 0
+                    -                            || (Double(batteryPercent) ?? 101) > 100
+                    -                            || appData.activeChargeSessionSummary(for: meter.btSerial.macAddress.description) == nil
+                    -                    )
+                    +                Button("Save Checkpoint") {
+                    +                    saveCheckpoint()
+                    +                .frame(maxWidth: .infinity)
+                    +                .padding(.vertical, 10)
+                    +                .meterCard(tint: .green, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
+                    +                .buttonStyle(.plain)
+                    +                .disabled(!canSave)
+                    +                .opacity(canSave ? 1 : 0.6)
+                    -        .navigationViewStyle(StackNavigationViewStyle())
+                    -        .alert(item: $confirmationWarning) { warning in
+                    -            Alert(
+                    -                title: Text(warning.title),
+                    -                message: Text(warning.message),
+                    -                primaryButton: .destructive(Text("Save Anyway")) {
+                    -                    saveCheckpoint(forceOverride: true)
+                    -                },
+                    -                secondaryButton: .cancel()
+                    -            )
+                    -        }
+                    -    private func saveCheckpoint(forceOverride: Bool = false) {
+                    -        guard let percent = Double(batteryPercent) else {
+                    -            return
+                    -        }
+                    -        if !forceOverride, let plausibilityWarning {
+                    -            confirmationWarning = plausibilityWarning
+                    +    private func saveCheckpoint() {
+                    +        guard let percent = normalizedBatteryPercent else {
+                                 return
+                    -        let didSave = appData.addBatteryCheckpoint(
+                    +        if appData.addBatteryCheckpoint(
+                                 percent: percent,
+                                 label: label,
+                    -            for: meter
+                    -        )
+                    -        if didSave {
+                    -            dismiss()
+                    +            for: sessionID,
+                    +            measuredEnergyWh: effectiveEnergyWhOverride,
+                    +            measuredChargeAh: measuredChargeAhOverride
+                    +        ) {
+                    +            onSaved?()
+                    +        }
+                    +    }
+                    +}
+                    +struct BatteryCheckpointEditorSheetView: View {
+                    +    @EnvironmentObject private var appData: AppData
+                    +    @EnvironmentObject private var meter: Meter
+                    +    @Environment(\.dismiss) private var dismiss
+                    +    private var activeSession: ChargeSessionSummary? {
+                    +        appData.activeChargeSessionSummary(for: meter.btSerial.macAddress.description)
+                    +    }
+                    +    var body: some View {
+                    +        NavigationView {
+                    +            Group {
+                    +                if let activeSession {
+                    +                    Form {
+                    +                        BatteryCheckpointEditorContentView(
+                    +                            sessionID: activeSession.id,
+                    +                            message: "The checkpoint is stored on the active charge session and later used for capacity estimation and the typical charge curve.",
+                    +                            effectiveEnergyWhOverride: nil,
+                    +                            measuredChargeAhOverride: nil,
+                    +                            onCancel: { dismiss() },
+                    +                            onSaved: { dismiss() }
+                    +                        )
+                    +                    }
+                    +                } else {
+                    +                    VStack(spacing: 12) {
+                    +                        Image(systemName: "bolt.slash")
+                    +                            .font(.title2)
+                    +                            .foregroundColor(.secondary)
+                    +                        Text("No Active Session")
+                    +                            .font(.headline)
+                    +                        Text("Start a charging session before adding a battery checkpoint.")
+                    +                            .font(.footnote)
+                    +                            .foregroundColor(.secondary)
+                    +                            .multilineTextAlignment(.center)
+                    +                    }
+                    +                    .padding(24)
+                    +                }
+                    +            }
+                    +            .navigationTitle("Battery Checkpoint")
+                    +            .navigationBarTitleDisplayMode(.inline)
+                    +        .navigationViewStyle(StackNavigationViewStyle())

+69 -97

USB Meter/Views/ChargedDevices/ChargedDeviceDetailView.swift

View

+                         @EnvironmentObject private var appData: AppData
+                         @Environment(\.dismiss) private var dismiss
+                         @State private var editorVisibility = false
+                    -    @State private var checkpointEditorVisibility = false
+                         @State private var targetNotificationEditorVisibility = false
+                         @State private var pendingSessionDeletion: ChargeSessionSummary?
+                    +    @State private var pendingCheckpointDeletion: ChargeCheckpointSummary?
+                         @State private var pendingSessionStopRequest: DeviceSessionStopRequest?
+                         @State private var deleteConfirmationVisibility = false
+                    +    @State private var showsInlineCheckpointEditor = false
+                         let chargedDeviceID: UUID
+                                     .environmentObject(appData)
+                    -        .sheet(isPresented: $checkpointEditorVisibility) {
+                    -            if let sessionID = appData.chargedDeviceSummary(id: chargedDeviceID)?.activeSession?.id {
+                    -                ChargedDeviceCheckpointEditorSheetView(sessionID: sessionID)
+                    -                    .environmentObject(appData)
+                    -            }
+                    -        }
+                             .sheet(isPresented: $targetNotificationEditorVisibility) {
+                                 if let activeSession = appData.chargedDeviceSummary(id: chargedDeviceID)?.activeSession {
+                                     ChargedDeviceTargetNotificationEditorSheetView(
+                                     secondaryButton: .cancel()
+                    +        .alert(item: $pendingCheckpointDeletion) { checkpoint in
+                    +            Alert(
+                    +                title: Text("Delete Battery Checkpoint"),
+                    +                message: Text("Remove the checkpoint at \(checkpoint.timestamp.format()) with \(checkpoint.batteryPercent.format(decimalDigits: 0))% from this session?"),
+                    +                primaryButton: .destructive(Text("Delete")) {
+                    +                    _ = appData.deleteBatteryCheckpoint(
+                    +                        checkpointID: checkpoint.id,
+                    +                        for: checkpoint.sessionID
+                    +                    )
+                    +                },
+                    +                secondaryButton: .cancel()
+                    +            )
+                    +        }
+                             .confirmationDialog("Delete \(deletionTitle)?", isPresented: $deleteConfirmationVisibility, titleVisibility: .visible) {
+                                 Button("Delete", role: .destructive) {
+                                     if appData.deleteChargedDevice(id: chargedDeviceID) {
+                             } message: {
+                                 Text(deletionMessage)
+                    +        .onChange(of: appData.chargedDeviceSummary(id: chargedDeviceID)?.activeSession?.id) { _ in
+                    +            showsInlineCheckpointEditor = false
+                    +        }
+                         private func headerCard(_ chargedDevice: ChargedDeviceSummary) -> some View {
+                                     .foregroundColor(.secondary)
+                    -            Button("Add Battery Checkpoint") {
+                    -                checkpointEditorVisibility = true
+                    +            if !activeSession.checkpoints.isEmpty {
+                    +                checkpointList(
+                    +                    checkpoints: Array(activeSession.checkpoints.suffix(6).reversed())
+                    +                )
+                    +            }
+                    +            Button(showsInlineCheckpointEditor ? "Hide Checkpoint Editor" : "Add Battery Checkpoint") {
+                    +                showsInlineCheckpointEditor.toggle()
+                                 .frame(maxWidth: .infinity)
+                                 .padding(.vertical, 10)
+                                 .meterCard(tint: .green, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
+                                 .buttonStyle(.plain)
+                    +            if showsInlineCheckpointEditor {
+                    +                BatteryCheckpointEditorContentView(
+                    +                    sessionID: activeSession.id,
+                    +                    message: "The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction.",
+                    +                    effectiveEnergyWhOverride: nil,
+                    +                    measuredChargeAhOverride: nil,
+                    +                    onCancel: { showsInlineCheckpointEditor = false },
+                    +                    onSaved: { showsInlineCheckpointEditor = false }
+                    +                )
+                    +            }
+                                 Button(activeSession.targetBatteryPercent == nil ? "Set Target Notification" : "Change Target Notification") {
+                                     targetNotificationEditorVisibility = true
+                             .meterCard(tint: .orange, fillOpacity: 0.14, strokeOpacity: 0.20, cornerRadius: 18)
+                    +    private func checkpointList(checkpoints: [ChargeCheckpointSummary]) -> some View {
+                    +        VStack(alignment: .leading, spacing: 8) {
+                    +            Text("Battery Checkpoints")
+                    +                .font(.subheadline.weight(.semibold))
+                    +            ForEach(checkpoints, id: \.id) { checkpoint in
+                    +                HStack {
+                    +                    Text(checkpoint.timestamp.format())
+                    +                        .font(.caption2)
+                    +                        .foregroundColor(.secondary)
+                    +                    Spacer()
+                    +                    Text("\(checkpoint.batteryPercent.format(decimalDigits: 0))%")
+                    +                        .font(.caption.weight(.semibold))
+                    +                    Text("•")
+                    +                        .foregroundColor(.secondary)
+                    +                    Text("\(checkpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh")
+                    +                        .font(.caption2)
+                    +                        .foregroundColor(.secondary)
+                    +                    Button {
+                    +                        pendingCheckpointDeletion = checkpoint
+                    +                    } label: {
+                    +                        Image(systemName: "trash")
+                    +                            .font(.caption.weight(.semibold))
+                    +                            .foregroundColor(.red)
+                    +                    }
+                    +                    .buttonStyle(.plain)
+                    +                    .help("Delete checkpoint")
+                    +                }
+                    +            }
+                    +        }
+                    +    }
+                         private func preferredStoredCurveSession(for chargedDevice: ChargedDeviceSummary) -> ChargeSessionSummary? {
+                             if let activeSession = chargedDevice.activeSession, !activeSession.aggregatedSamples.isEmpty {
+                                 return activeSession
+                    -private struct ChargedDeviceCheckpointEditorSheetView: View {
+                    -    @Environment(\.dismiss) private var dismiss
+                    -    @EnvironmentObject private var appData: AppData
+                    -    let sessionID: UUID
+                    -    @State private var batteryPercent = ""
+                    -    @State private var label = ""
+                    -    @State private var confirmationWarning: BatteryCheckpointPlausibilityWarning?
+                    -    private var plausibilityWarning: BatteryCheckpointPlausibilityWarning? {
+                    -        guard let percent = Double(batteryPercent) else {
+                    -            return nil
+                    -        }
+                    -        return appData.batteryCheckpointPlausibilityWarning(percent: percent, for: sessionID)
+                    -    }
+                    -    var body: some View {
+                    -        NavigationView {
+                    -            Form {
+                    -                Section(
+                    -                    header: ContextInfoHeader(
+                    -                        title: "Checkpoint",
+                    -                        message: "The checkpoint is stored on the active charge session and is used for capacity estimation and charge-level prediction."
+                    -                    )
+                    -                ) {
+                    -                    TextField("Battery %", text: $batteryPercent)
+                    -                        .keyboardType(.decimalPad)
+                    -                    TextField("Label (optional)", text: $label)
+                    -                }
+                    -                if let plausibilityWarning {
+                    -                    Section(header: Text(plausibilityWarning.title)) {
+                    -                        Text(plausibilityWarning.message)
+                    -                            .font(.footnote)
+                    -                            .foregroundColor(.orange)
+                    -                    }
+                    -                }
+                    -            }
+                    -            .navigationTitle("Battery Checkpoint")
+                    -            .navigationBarTitleDisplayMode(.inline)
+                    -            .toolbar {
+                    -                ToolbarItem(placement: .cancellationAction) {
+                    -                    Button("Cancel") {
+                    -                        dismiss()
+                    -                    }
+                    -                }
+                    -                ToolbarItem(placement: .confirmationAction) {
+                    -                    Button("Save") {
+                    -                        saveCheckpoint()
+                    -                    }
+                    -                    .disabled(
+                    -                        (Double(batteryPercent) ?? -1) < 0
+                    -                            || (Double(batteryPercent) ?? 101) > 100
+                    -                    )
+                    -                }
+                    -            }
+                    -        }
+                    -        .navigationViewStyle(StackNavigationViewStyle())
+                    -        .alert(item: $confirmationWarning) { warning in
+                    -            Alert(
+                    -                title: Text(warning.title),
+                    -                message: Text(warning.message),
+                    -                primaryButton: .destructive(Text("Save Anyway")) {
+                    -                    saveCheckpoint(forceOverride: true)
+                    -                },
+                    -                secondaryButton: .cancel()
+                    -            )
+                    -        }
+                    -    }
+                    -    private func saveCheckpoint(forceOverride: Bool = false) {
+                    -        guard let percent = Double(batteryPercent) else {
+                    -            return
+                    -        }
+                    -        if !forceOverride, let plausibilityWarning {
+                    -            confirmationWarning = plausibilityWarning
+                    -            return
+                    -        }
+                    -        if appData.addBatteryCheckpoint(percent: percent, label: label, for: sessionID) {
+                    -            dismiss()
+                    -        }
+                    -    }
+                    -}
+                     private struct ChargedDeviceTargetNotificationEditorSheetView: View {
+                         @Environment(\.dismiss) private var dismiss
+                         @EnvironmentObject private var appData: AppData

+71 -39

USB Meter/Views/Meter/Tabs/ChargeRecord/MeterChargeRecordTabView.swift

View

@@ -36,7 +36,6 @@ struct MeterChargeRecordContentView: View {
 
     @State private var chargedDeviceLibraryVisibility = false
     @State private var chargerLibraryVisibility = false
-    @State private var checkpointEditorVisibility = false
     @State private var editingChargedDevice: ChargedDeviceSummary?
     @State private var targetNotificationEditorVisibility = false
     @State private var pendingStopRequest: ChargeSessionStopRequest?
@@ -46,6 +45,7 @@ struct MeterChargeRecordContentView: View {
     @State private var initialCheckpointMode: InitialCheckpointMode = .known
     @State private var initialCheckpoint = ""
     @State private var showsMeterTotalsInfo = false
+    @State private var showsInlineCheckpointEditor = false
 
     private enum SessionStartRequirement: Identifiable {
         case existingSession
@@ -143,11 +143,6 @@ struct MeterChargeRecordContentView: View {
             )
             .environmentObject(appData)
         }
-        .sheet(isPresented: $checkpointEditorVisibility) {
-            BatteryCheckpointEditorSheetView()
-                .environmentObject(appData)
-                .environmentObject(usbMeter)
-        }
         .sheet(item: $editingChargedDevice) { chargedDevice in
             ChargedDeviceEditorSheetView(
                 meterMACAddress: nil,
@@ -197,6 +192,7 @@ struct MeterChargeRecordContentView: View {
         }
         .onChange(of: openChargeSession?.id) { _ in
             syncDraftSelections()
+            showsInlineCheckpointEditor = false
         }
     }
 
@@ -730,6 +726,7 @@ struct MeterChargeRecordContentView: View {
 
     private func chargingMonitorCard(_ openChargeSession: ChargeSessionSummary) -> some View {
         let displayedEnergyWh = displayedSessionEnergyWh(for: openChargeSession)
+        let displayedChargeAh = displayedSessionChargeAh(for: openChargeSession)
         return VStack(alignment: .leading, spacing: 12) {
             HStack(spacing: 8) {
                 Text("Charging Monitor")
@@ -797,14 +794,31 @@ struct MeterChargeRecordContentView: View {
                     .foregroundColor(.secondary)
             }
 
-            Button("Add Battery Checkpoint") {
-                checkpointEditorVisibility = true
+            if !openChargeSession.checkpoints.isEmpty {
+                checkpointList(
+                    checkpoints: Array(openChargeSession.checkpoints.suffix(6).reversed())
+                )
+            }
+
+            Button(showsInlineCheckpointEditor ? "Hide Checkpoint Editor" : "Add Battery Checkpoint") {
+                showsInlineCheckpointEditor.toggle()
             }
             .frame(maxWidth: .infinity)
             .padding(.vertical, 10)
             .meterCard(tint: .green, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
             .buttonStyle(.plain)
 
+            if showsInlineCheckpointEditor {
+                BatteryCheckpointEditorContentView(
+                    sessionID: openChargeSession.id,
+                    message: "The checkpoint is stored on the active charge session and later used for capacity estimation and the typical charge curve.",
+                    effectiveEnergyWhOverride: displayedEnergyWh,
+                    measuredChargeAhOverride: displayedChargeAh,
+                    onCancel: { showsInlineCheckpointEditor = false },
+                    onSaved: { showsInlineCheckpointEditor = false }
+                )
+            }
+
             Button(openChargeSession.targetBatteryPercent == nil ? "Set Target Notification" : "Change Target Notification") {
                 targetNotificationEditorVisibility = true
             }
@@ -854,37 +868,6 @@ struct MeterChargeRecordContentView: View {
             .meterCard(tint: .red, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
             .buttonStyle(.plain)
 
-            if !openChargeSession.checkpoints.isEmpty {
-                let recentCheckpoints = Array(openChargeSession.checkpoints.suffix(6).reversed())
-                VStack(alignment: .leading, spacing: 8) {
-                    Text("Battery Checkpoints")
-                        .font(.subheadline.weight(.semibold))
-
-                    ForEach(recentCheckpoints, id: \.id) { checkpoint in
-                        HStack {
-                            Text(checkpoint.timestamp.format())
-                                .font(.caption2)
-                                .foregroundColor(.secondary)
-                            Spacer()
-                            Text("\(checkpoint.batteryPercent.format(decimalDigits: 0))%")
-                                .font(.caption.weight(.semibold))
-                            Text("•")
-                                .foregroundColor(.secondary)
-                            Text("\(checkpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh")
-                                .font(.caption2)
-                                .foregroundColor(.secondary)
-                            Button {
-                                pendingCheckpointDeletion = checkpoint
-                            } label: {
-                                Image(systemName: "trash")
-                                    .font(.caption.weight(.semibold))
-                                    .foregroundColor(.red)
-                            }
-                            .buttonStyle(.plain)
-                        }
-                    }
-                }
-            }
         }
         .padding(18)
         .meterCard(tint: .green, fillOpacity: 0.14, strokeOpacity: 0.20)
@@ -1049,6 +1032,55 @@ struct MeterChargeRecordContentView: View {
         return storedEnergyWh
     }
 
+    private func displayedSessionChargeAh(for session: ChargeSessionSummary) -> Double {
+        let storedChargeAh = session.measuredChargeAh
+        guard session.status.isOpen else {
+            return storedChargeAh
+        }
+
+        guard session.meterMACAddress == meterMACAddress else {
+            return storedChargeAh
+        }
+
+        if let baselineChargeAh = session.meterChargeBaselineAh {
+            return max(storedChargeAh, max(usbMeter.recordedAH - baselineChargeAh, 0))
+        }
+
+        return storedChargeAh
+    }
+
+    private func checkpointList(checkpoints: [ChargeCheckpointSummary]) -> some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text("Battery Checkpoints")
+                .font(.subheadline.weight(.semibold))
+
+            ForEach(checkpoints, id: \.id) { checkpoint in
+                HStack {
+                    Text(checkpoint.timestamp.format())
+                        .font(.caption2)
+                        .foregroundColor(.secondary)
+                    Spacer()
+                    Text("\(checkpoint.batteryPercent.format(decimalDigits: 0))%")
+                        .font(.caption.weight(.semibold))
+                    Text("•")
+                        .foregroundColor(.secondary)
+                    Text("\(checkpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh")
+                        .font(.caption2)
+                        .foregroundColor(.secondary)
+                    Button {
+                        pendingCheckpointDeletion = checkpoint
+                    } label: {
+                        Image(systemName: "trash")
+                            .font(.caption.weight(.semibold))
+                            .foregroundColor(.red)
+                    }
+                    .buttonStyle(.plain)
+                    .help("Delete checkpoint")
+                }
+            }
+        }
+    }
+
     private func formatDuration(_ duration: TimeInterval) -> String {
         let totalSeconds = Int(duration.rounded(.down))
         let hours = totalSeconds / 3600


	@@ -581,7 +581,9 @@ final class ChargeInsightsStore {
581	581	func addBatteryCheckpoint(
582	582	percent: Double,
583	583	label: String?,
584		- for sessionID: UUID
	584	+ for sessionID: UUID,
	585	+ measuredEnergyWh: Double? = nil,
	586	+ measuredChargeAh: Double? = nil
585	587	) -> Bool {
586	588	guard percent.isFinite, percent >= 0, percent <= 100 else {
587	589	return false
	@@ -593,7 +595,13 @@ final class ChargeInsightsStore {
593	595	return
594	596	}
595	597
596		- didSave = addBatteryCheckpoint(percent: percent, label: label, to: session)
	598	+ didSave = addBatteryCheckpoint(
	599	+ percent: percent,
	600	+ label: label,
	601	+ measuredEnergyWh: measuredEnergyWh,
	602	+ measuredChargeAh: measuredChargeAh,
	603	+ to: session
	604	+ )
597	605	}
598	606	return didSave
599	607	}
	@@ -617,16 +625,11 @@ final class ChargeInsightsStore {
617	625	context.delete(checkpoint)
618	626	refreshCheckpointDerivedValues(for: session)
619	627
620		- guard saveContext() else {
621		- return
622		- }
623		-
624	628	if let chargedDeviceID {
625	629	refreshDerivedMetrics(forChargedDeviceID: chargedDeviceID)
626		- didSave = saveContext()
627		- } else {
628		- didSave = true
629	630	}
	631	+
	632	+ didSave = saveContext()
630	633	}
631	634	return didSave
632	635	}
	@@ -856,12 +859,18 @@ final class ChargeInsightsStore {
856	859	let devices = fetchObjects(entityName: EntityName.chargedDevice)
857	860	let sessions = fetchObjects(entityName: EntityName.chargeSession)
858	861	let checkpoints = fetchObjects(entityName: EntityName.chargeCheckpoint)
859		- let sessionSamples = fetchObjects(entityName: EntityName.chargeSessionSample)
860	862
861	863	let checkpointsBySessionID = Dictionary(grouping: checkpoints) { stringValue($0, key: "sessionID") ?? "" }
862		- let samplesBySessionID = Dictionary(grouping: sessionSamples) { stringValue($0, key: "sessionID") ?? "" }
863	864	let sessionsByDeviceID = Dictionary(grouping: sessions) { stringValue($0, key: "chargedDeviceID") ?? "" }
864	865	let sessionsByChargerID = Dictionary(grouping: sessions) { stringValue($0, key: "chargerID") ?? "" }
	866	+ let sampleBackedSessionIDs = sampleBackedSessionIDs(
	867	+ devices: devices,
	868	+ sessionsByDeviceID: sessionsByDeviceID,
	869	+ sessionsByChargerID: sessionsByChargerID
	870	+ )
	871	+ let samplesBySessionID = Dictionary(
	872	+ grouping: fetchSessionSampleObjects(forSessionIDs: Array(sampleBackedSessionIDs))
	873	+ ) { stringValue($0, key: "sessionID") ?? "" }
865	874
866	875	summaries = devices.compactMap { device in
867	876	guard
	@@ -2111,6 +2120,16 @@ final class ChargeInsightsStore {
2111	2120	return (try? context.fetch(request)) ?? []
2112	2121	}
2113	2122
	2123	+ private func fetchSessionSampleObjects(forSessionIDs sessionIDs: [String]) -> [NSManagedObject] {
	2124	+ guard !sessionIDs.isEmpty else {
	2125	+ return []
	2126	+ }
	2127	+
	2128	+ let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargeSessionSample)
	2129	+ request.predicate = NSPredicate(format: "sessionID IN %@", sessionIDs)
	2130	+ return (try? context.fetch(request)) ?? []
	2131	+ }
	2132	+
2114	2133	private func fetchCheckpointObject(id: String, sessionID: String) -> NSManagedObject? {
2115	2134	let request = NSFetchRequest<NSManagedObject>(entityName: EntityName.chargeCheckpoint)
2116	2135	request.predicate = NSPredicate(format: "id == %@ AND sessionID == %@", id, sessionID)
	@@ -2139,6 +2158,68 @@ final class ChargeInsightsStore {
2139	2158	return (try? context.fetch(request)) ?? []
2140	2159	}
2141	2160
	2161	+ private func sampleBackedSessionIDs(
	2162	+ devices: [NSManagedObject],
	2163	+ sessionsByDeviceID: [String: [NSManagedObject]],
	2164	+ sessionsByChargerID: [String: [NSManagedObject]]
	2165	+ ) -> Set<String> {
	2166	+ var sessionIDs: Set<String> = []
	2167	+
	2168	+ for device in devices {
	2169	+ guard
	2170	+ let deviceID = stringValue(device, key: "id"),
	2171	+ let rawClass = stringValue(device, key: "deviceClassRawValue"),
	2172	+ let deviceClass = ChargedDeviceClass(rawValue: rawClass)
	2173	+ else {
	2174	+ continue
	2175	+ }
	2176	+
	2177	+ let relevantSessions = relevantSessionObjects(
	2178	+ for: deviceID,
	2179	+ deviceClass: deviceClass,
	2180	+ sessionsByDeviceID: sessionsByDeviceID,
	2181	+ sessionsByChargerID: sessionsByChargerID
	2182	+ )
	2183	+ .sorted { lhs, rhs in
	2184	+ let lhsStatus = statusValue(lhs, key: "statusRawValue") ?? .completed
	2185	+ let rhsStatus = statusValue(rhs, key: "statusRawValue") ?? .completed
	2186	+
	2187	+ if lhsStatus.isOpen && !rhsStatus.isOpen {
	2188	+ return true
	2189	+ }
	2190	+ if !lhsStatus.isOpen && rhsStatus.isOpen {
	2191	+ return false
	2192	+ }
	2193	+
	2194	+ return (dateValue(lhs, key: "startedAt") ?? .distantPast)
	2195	+ > (dateValue(rhs, key: "startedAt") ?? .distantPast)
	2196	+ }
	2197	+
	2198	+ var recentCompletedSamplesIncluded = 0
	2199	+
	2200	+ for session in relevantSessions {
	2201	+ guard let sessionID = stringValue(session, key: "id"),
	2202	+ let status = statusValue(session, key: "statusRawValue") else {
	2203	+ continue
	2204	+ }
	2205	+
	2206	+ if status.isOpen {
	2207	+ sessionIDs.insert(sessionID)
	2208	+ continue
	2209	+ }
	2210	+
	2211	+ guard recentCompletedSamplesIncluded < 2 else {
	2212	+ continue
	2213	+ }
	2214	+
	2215	+ sessionIDs.insert(sessionID)
	2216	+ recentCompletedSamplesIncluded += 1
	2217	+ }
	2218	+ }
	2219	+
	2220	+ return sessionIDs
	2221	+ }
	2222	+
2142	2223	private func relevantSessionObjects(
2143	2224	for chargedDeviceID: String,
2144	2225	deviceClass: ChargedDeviceClass,

	@@ -42,6 +42,7 @@ final class AppData : ObservableObject {
42	42	private var chargeInsightsStoreObserver: AnyCancellable?
43	43	private var chargeInsightsRemoteObserver: AnyCancellable?
44	44	private var chargerStandbyPowerStoreObserver: AnyCancellable?
	45	+ private var pendingChargedDevicesReloadWorkItem: DispatchWorkItem?
45	46	private let meterStore = MeterNameStore.shared
46	47	private var chargeInsightsStore: ChargeInsightsStore?
47	48	private let chargerStandbyPowerStore = ChargerStandbyPowerStore()
	@@ -103,7 +104,7 @@ final class AppData : ObservableObject {
103	104	)
104	105	.receive(on: DispatchQueue.main)
105	106	.sink { [weak self] _ in
106		- self?.reloadChargedDevices()
	107	+ self?.scheduleChargedDevicesReload()
107	108	}
108	109
109	110	chargeInsightsRemoteObserver = NotificationCenter.default.publisher(
	@@ -112,7 +113,7 @@ final class AppData : ObservableObject {
112	113	)
113	114	.receive(on: DispatchQueue.main)
114	115	.sink { [weak self] _ in
115		- self?.reloadChargedDevices()
	116	+ self?.scheduleChargedDevicesReload()
116	117	}
117	118
118	119	chargeNotificationCoordinator.ensureAuthorizationIfNeeded()
	@@ -194,7 +195,7 @@ final class AppData : ObservableObject {
194	195	func currentChargedDeviceSummary(for meterMACAddress: String) -> ChargedDeviceSummary? {
195	196	let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
196	197
197		- if let activeSession = activeChargeSessionSummary(for: normalizedMAC),
	198	+ if let activeSession = cachedActiveChargeSessionSummary(for: normalizedMAC),
198	199	let liveDevice = chargedDevices.first(where: {
199	200	$0.id == activeSession.chargedDeviceID && $0.isCharger == false
200	201	}) {
	@@ -209,7 +210,7 @@ final class AppData : ObservableObject {
209	210	func currentChargerSummary(for meterMACAddress: String) -> ChargedDeviceSummary? {
210	211	let normalizedMAC = meterMACAddress.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
211	212
212		- if let activeSession = activeChargeSessionSummary(for: normalizedMAC),
	213	+ if let activeSession = cachedActiveChargeSessionSummary(for: normalizedMAC),
213	214	let chargerID = activeSession.chargerID,
214	215	let liveCharger = chargedDevices.first(where: {
215	216	$0.id == chargerID && $0.isCharger
	@@ -223,7 +224,10 @@ final class AppData : ObservableObject {
223	224	}
224	225
225	226	func activeChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {
226		- chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: meterMACAddress)
	227	+ if let cachedSummary = cachedActiveChargeSessionSummary(for: meterMACAddress) {
	228	+ return cachedSummary
	229	+ }
	230	+ return chargeInsightsStore?.activeChargeSessionSummary(forMeterMACAddress: meterMACAddress)
227	231	}
228	232
229	233	func chargerStandbyMeasurementSession(for meterMACAddress: String) -> ChargerStandbyPowerMonitorSession? {
	@@ -557,14 +561,42 @@ final class AppData : ObservableObject {
557	561	return didSave
558	562	}
559	563
	564	+ @discardableResult
	565	+ func addBatteryCheckpoint(
	566	+ percent: Double,
	567	+ label: String?,
	568	+ for sessionID: UUID,
	569	+ measuredEnergyWh: Double?,
	570	+ measuredChargeAh: Double?
	571	+ ) -> Bool {
	572	+ let didSave = chargeInsightsStore?.addBatteryCheckpoint(
	573	+ percent: percent,
	574	+ label: label,
	575	+ for: sessionID,
	576	+ measuredEnergyWh: measuredEnergyWh,
	577	+ measuredChargeAh: measuredChargeAh
	578	+ ) ?? false
	579	+
	580	+ if didSave {
	581	+ reloadChargedDevices()
	582	+ }
	583	+
	584	+ return didSave
	585	+ }
	586	+
560	587	func batteryCheckpointPlausibilityWarning(
561	588	percent: Double,
562		- for sessionID: UUID
	589	+ for sessionID: UUID,
	590	+ effectiveEnergyWhOverride: Double? = nil
563	591	) -> BatteryCheckpointPlausibilityWarning? {
564	592	guard let session = chargeSessionSummary(id: sessionID) else {
565	593	return nil
566	594	}
567		- return batteryCheckpointPlausibilityWarning(percent: percent, for: session)
	595	+ return batteryCheckpointPlausibilityWarning(
	596	+ percent: percent,
	597	+ for: session,
	598	+ effectiveEnergyWhOverride: effectiveEnergyWhOverride
	599	+ )
568	600	}
569	601
570	602	@discardableResult
	@@ -575,7 +607,7 @@ final class AppData : ObservableObject {
575	607	) ?? false
576	608
577	609	if didDelete {
578		- reloadChargedDevices()
	610	+ scheduleChargedDevicesReload(delay: 0)
579	611	}
580	612
581	613	return didDelete
	@@ -756,7 +788,32 @@ final class AppData : ObservableObject {
756	788	}
757	789	}
758	790
	791	+ private func scheduleChargedDevicesReload(delay: TimeInterval = 0.15) {
	792	+ pendingChargedDevicesReloadWorkItem?.cancel()
	793	+
	794	+ let workItem = DispatchWorkItem { [weak self] in
	795	+ self?.reloadChargedDevices()
	796	+ }
	797	+ pendingChargedDevicesReloadWorkItem = workItem
	798	+ DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: workItem)
	799	+ }
	800	+
	801	+ private func cachedActiveChargeSessionSummary(for meterMACAddress: String) -> ChargeSessionSummary? {
	802	+ let normalizedMAC = Self.normalizedMACAddress(meterMACAddress)
	803	+ guard !normalizedMAC.isEmpty else {
	804	+ return nil
	805	+ }
	806	+
	807	+ return chargedDevices
	808	+ .lazy
	809	+ .compactMap(\.activeSession)
	810	+ .first(where: { $0.status == .active && $0.meterMACAddress == normalizedMAC })
	811	+ }
	812	+
759	813	private func reloadChargedDevices() {
	814	+ pendingChargedDevicesReloadWorkItem?.cancel()
	815	+ pendingChargedDevicesReloadWorkItem = nil
	816	+
760	817	let standbyMeasurementsByChargerID = chargerStandbyPowerStore.measurementsByChargerID()
761	818	chargedDevices = (chargeInsightsStore?.fetchChargedDeviceSummaries() ?? []).map { chargedDevice in
762	819	chargedDevice.withStandbyPowerMeasurements(
	@@ -823,7 +880,8 @@ final class AppData : ObservableObject {
823	880
824	881	private func batteryCheckpointPlausibilityWarning(
825	882	percent: Double,
826		- for session: ChargeSessionSummary
	883	+ for session: ChargeSessionSummary,
	884	+ effectiveEnergyWhOverride: Double? = nil
827	885	) -> BatteryCheckpointPlausibilityWarning? {
828	886	guard percent.isFinite, percent >= 0, percent <= 100 else {
829	887	return nil
	@@ -847,8 +905,46 @@ final class AppData : ObservableObject {
847	905	)
848	906	}
849	907
	908	+ let effectiveEnergyWh = effectiveEnergyWhOverride
	909	+ ?? session.effectiveBatteryEnergyWh
	910	+ ?? session.measuredEnergyWh
	911	+
	912	+ if let lastCheckpoint = sortedCheckpoints.last,
	913	+ let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID) {
	914	+ let estimatedCapacityWh = session.capacityEstimateWh
	915	+ ?? chargedDevice.estimatedBatteryCapacityWh(for: session.chargingTransportMode)
	916	+ ?? chargedDevice.estimatedBatteryCapacityWh
	917	+
	918	+ if let estimatedCapacityWh, estimatedCapacityWh > 0 {
	919	+ let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)
	920	+ let expectedPercent = min(
	921	+ 100,
	922	+ max(
	923	+ lastCheckpoint.batteryPercent,
	924	+ lastCheckpoint.batteryPercent + (energyDeltaWh / estimatedCapacityWh) * 100
	925	+ )
	926	+ )
	927	+ let predictionGap = percent - expectedPercent
	928	+ guard abs(predictionGap) >= 4 else {
	929	+ return nil
	930	+ }
	931	+
	932	+ let direction = predictionGap > 0 ? "above" : "below"
	933	+ let gapText = abs(predictionGap).format(decimalDigits: 0)
	934	+ let expectedText = expectedPercent.format(decimalDigits: 0)
	935	+
	936	+ return BatteryCheckpointPlausibilityWarning(
	937	+ title: "Checkpoint Looks Implausible",
	938	+ message: "The last checkpoint stored \(lastCheckpoint.batteryPercent.format(decimalDigits: 0))% at \(lastCheckpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh. The current counted energy is \(effectiveEnergyWh.format(decimalDigits: 2)) Wh, which supports about \(expectedText)% based on \(estimatedCapacityWh.format(decimalDigits: 2)) Wh capacity. The entered value is about \(gapText) percentage points \(direction) that."
	939	+ )
	940	+ }
	941	+ }
	942	+
850	943	guard let chargedDevice = chargedDeviceSummary(id: session.chargedDeviceID),
851		- let prediction = chargedDevice.batteryLevelPrediction(for: session)
	944	+ let prediction = chargedDevice.batteryLevelPrediction(
	945	+ for: session,
	946	+ effectiveEnergyWhOverride: effectiveEnergyWh
	947	+ )
852	948	else {
853	949	return nil
854	950	}
	@@ -863,7 +959,6 @@ final class AppData : ObservableObject {
863	959	let predictedText = prediction.predictedPercent.format(decimalDigits: 0)
864	960
865	961	if let lastCheckpoint = sortedCheckpoints.last {
866		- let effectiveEnergyWh = session.effectiveBatteryEnergyWh ?? session.measuredEnergyWh
867	962	let energyDeltaWh = max(effectiveEnergyWh - lastCheckpoint.measuredEnergyWh, 0)
868	963	return BatteryCheckpointPlausibilityWarning(
869	964	title: "Checkpoint Looks Implausible",

	@@ -36,7 +36,6 @@ struct MeterChargeRecordContentView: View {
36	36
37	37	@State private var chargedDeviceLibraryVisibility = false
38	38	@State private var chargerLibraryVisibility = false
39		- @State private var checkpointEditorVisibility = false
40	39	@State private var editingChargedDevice: ChargedDeviceSummary?
41	40	@State private var targetNotificationEditorVisibility = false
42	41	@State private var pendingStopRequest: ChargeSessionStopRequest?
	@@ -46,6 +45,7 @@ struct MeterChargeRecordContentView: View {
46	45	@State private var initialCheckpointMode: InitialCheckpointMode = .known
47	46	@State private var initialCheckpoint = ""
48	47	@State private var showsMeterTotalsInfo = false
	48	+ @State private var showsInlineCheckpointEditor = false
49	49
50	50	private enum SessionStartRequirement: Identifiable {
51	51	case existingSession
	@@ -143,11 +143,6 @@ struct MeterChargeRecordContentView: View {
143	143	)
144	144	.environmentObject(appData)
145	145	}
146		- .sheet(isPresented: $checkpointEditorVisibility) {
147		- BatteryCheckpointEditorSheetView()
148		- .environmentObject(appData)
149		- .environmentObject(usbMeter)
150		- }
151	146	.sheet(item: $editingChargedDevice) { chargedDevice in
152	147	ChargedDeviceEditorSheetView(
153	148	meterMACAddress: nil,
	@@ -197,6 +192,7 @@ struct MeterChargeRecordContentView: View {
197	192	}
198	193	.onChange(of: openChargeSession?.id) { _ in
199	194	syncDraftSelections()
	195	+ showsInlineCheckpointEditor = false
200	196	}
201	197	}
202	198
	@@ -730,6 +726,7 @@ struct MeterChargeRecordContentView: View {
730	726
731	727	private func chargingMonitorCard(_ openChargeSession: ChargeSessionSummary) -> some View {
732	728	let displayedEnergyWh = displayedSessionEnergyWh(for: openChargeSession)
	729	+ let displayedChargeAh = displayedSessionChargeAh(for: openChargeSession)
733	730	return VStack(alignment: .leading, spacing: 12) {
734	731	HStack(spacing: 8) {
735	732	Text("Charging Monitor")
	@@ -797,14 +794,31 @@ struct MeterChargeRecordContentView: View {
797	794	.foregroundColor(.secondary)
798	795	}
799	796
800		- Button("Add Battery Checkpoint") {
801		- checkpointEditorVisibility = true
	797	+ if !openChargeSession.checkpoints.isEmpty {
	798	+ checkpointList(
	799	+ checkpoints: Array(openChargeSession.checkpoints.suffix(6).reversed())
	800	+ )
	801	+ }
	802	+
	803	+ Button(showsInlineCheckpointEditor ? "Hide Checkpoint Editor" : "Add Battery Checkpoint") {
	804	+ showsInlineCheckpointEditor.toggle()
802	805	}
803	806	.frame(maxWidth: .infinity)
804	807	.padding(.vertical, 10)
805	808	.meterCard(tint: .green, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
806	809	.buttonStyle(.plain)
807	810
	811	+ if showsInlineCheckpointEditor {
	812	+ BatteryCheckpointEditorContentView(
	813	+ sessionID: openChargeSession.id,
	814	+ message: "The checkpoint is stored on the active charge session and later used for capacity estimation and the typical charge curve.",
	815	+ effectiveEnergyWhOverride: displayedEnergyWh,
	816	+ measuredChargeAhOverride: displayedChargeAh,
	817	+ onCancel: { showsInlineCheckpointEditor = false },
	818	+ onSaved: { showsInlineCheckpointEditor = false }
	819	+ )
	820	+ }
	821	+
808	822	Button(openChargeSession.targetBatteryPercent == nil ? "Set Target Notification" : "Change Target Notification") {
809	823	targetNotificationEditorVisibility = true
810	824	}
	@@ -854,37 +868,6 @@ struct MeterChargeRecordContentView: View {
854	868	.meterCard(tint: .red, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)
855	869	.buttonStyle(.plain)
856	870
857		- if !openChargeSession.checkpoints.isEmpty {
858		- let recentCheckpoints = Array(openChargeSession.checkpoints.suffix(6).reversed())
859		- VStack(alignment: .leading, spacing: 8) {
860		- Text("Battery Checkpoints")
861		- .font(.subheadline.weight(.semibold))
862		-
863		- ForEach(recentCheckpoints, id: \.id) { checkpoint in
864		- HStack {
865		- Text(checkpoint.timestamp.format())
866		- .font(.caption2)
867		- .foregroundColor(.secondary)
868		- Spacer()
869		- Text("\(checkpoint.batteryPercent.format(decimalDigits: 0))%")
870		- .font(.caption.weight(.semibold))
871		- Text("•")
872		- .foregroundColor(.secondary)
873		- Text("\(checkpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh")
874		- .font(.caption2)
875		- .foregroundColor(.secondary)
876		- Button {
877		- pendingCheckpointDeletion = checkpoint
878		- } label: {
879		- Image(systemName: "trash")
880		- .font(.caption.weight(.semibold))
881		- .foregroundColor(.red)
882		- }
883		- .buttonStyle(.plain)
884		- }
885		- }
886		- }
887		- }
888	871	}
889	872	.padding(18)
890	873	.meterCard(tint: .green, fillOpacity: 0.14, strokeOpacity: 0.20)
	@@ -1049,6 +1032,55 @@ struct MeterChargeRecordContentView: View {
1049	1032	return storedEnergyWh
1050	1033	}
1051	1034
	1035	+ private func displayedSessionChargeAh(for session: ChargeSessionSummary) -> Double {
	1036	+ let storedChargeAh = session.measuredChargeAh
	1037	+ guard session.status.isOpen else {
	1038	+ return storedChargeAh
	1039	+ }
	1040	+
	1041	+ guard session.meterMACAddress == meterMACAddress else {
	1042	+ return storedChargeAh
	1043	+ }
	1044	+
	1045	+ if let baselineChargeAh = session.meterChargeBaselineAh {
	1046	+ return max(storedChargeAh, max(usbMeter.recordedAH - baselineChargeAh, 0))
	1047	+ }
	1048	+
	1049	+ return storedChargeAh
	1050	+ }
	1051	+
	1052	+ private func checkpointList(checkpoints: [ChargeCheckpointSummary]) -> some View {
	1053	+ VStack(alignment: .leading, spacing: 8) {
	1054	+ Text("Battery Checkpoints")
	1055	+ .font(.subheadline.weight(.semibold))
	1056	+
	1057	+ ForEach(checkpoints, id: \.id) { checkpoint in
	1058	+ HStack {
	1059	+ Text(checkpoint.timestamp.format())
	1060	+ .font(.caption2)
	1061	+ .foregroundColor(.secondary)
	1062	+ Spacer()
	1063	+ Text("\(checkpoint.batteryPercent.format(decimalDigits: 0))%")
	1064	+ .font(.caption.weight(.semibold))
	1065	+ Text("•")
	1066	+ .foregroundColor(.secondary)
	1067	+ Text("\(checkpoint.measuredEnergyWh.format(decimalDigits: 2)) Wh")
	1068	+ .font(.caption2)
	1069	+ .foregroundColor(.secondary)
	1070	+ Button {
	1071	+ pendingCheckpointDeletion = checkpoint
	1072	+ } label: {
	1073	+ Image(systemName: "trash")
	1074	+ .font(.caption.weight(.semibold))
	1075	+ .foregroundColor(.red)
	1076	+ }
	1077	+ .buttonStyle(.plain)
	1078	+ .help("Delete checkpoint")
	1079	+ }
	1080	+ }
	1081	+ }
	1082	+ }
	1083	+
1052	1084	private func formatDuration(_ duration: TimeInterval) -> String {
1053	1085	let totalSeconds = Int(duration.rounded(.down))
1054	1086	let hours = totalSeconds / 3600