+# Charging While Off

+

+## Definition

+

+A device that **can charge while off** can continue charging its battery when it is powered down (screen off, OS not running).

+

+In practice, this is the *general rule* for many battery-powered devices. The important exceptions are:

+

+- some devices **auto-boot when power is connected**, so they do not reliably stay off while charging

+- some devices **cannot be turned off**, so an off-state session is not possible

+- some devices **only charge while off**, meaning they must be powered down to accept charge

+

+## How the app should decide ON vs OFF

+

+When information is available, the app should decide the charging mode automatically:

+

+- If the available information clearly indicates **ON** or **OFF**, use it.

+- If the information indicates multiple plausible variants, show a **non-intrusive hint** that the user should specify whether the session is **ON** or **OFF**.

+- If no information is available, the app assumes **ON** for devices that support **both ON and OFF charging** (for capacity learning and confidence rules).

+

+## Why it matters for battery capacity estimation

+

+Off-state charging sessions tend to produce the cleanest signal for estimating battery capacity (energy stored):

+

+- Most of the measured input energy goes into the battery, instead of being consumed by the device itself.

+- The result is less affected by background processes, radios, thermal throttling, screen usage, and OS-level behavior.

+

+## App implications

+

+### Defaults

+

+- **Default assumption (for capacity learning):** if the user does not specify otherwise, a device is treated as **on/unknown-state** while charging.

+

+### Capacity estimation priority (conceptual rule)

+

+When we have both:

+

+- high-confidence capacity determinations from **off-state** charging, and

+- lower-confidence determinations from **on/unknown** charging,

+

+then:

+

+- off-state determinations are **preferred** for establishing the device’s capacity baseline

+- on/unknown determinations **must not overwrite** off-state determinations, **except** when they imply a **smaller capacity**

+  - example: the user logs a large measured energy, but later battery-percent checkpoints indicate the battery can’t actually hold that much energy (or has degraded), so we allow the estimate to move downward

+

+### Current implementation note

+

+For devices that are **not** marked as chargeable while off, the app **does not accept sessions that end at “full”** as capacity inputs (near-full can hide unknown “top-off” time/energy while the OS is doing its own work). For devices marked as chargeable while off, full / near-full sessions remain eligible.

+

+## Device-specific notes (practical guidance)

+

+- **iPhone:** tends to auto-boot when connected to a charger. To record an off-state session, you may need to shut it down after connecting power. Some factors can still trigger a boot even if the phone was shut down.

+- **Powerbank:** treat as “chargeable only while off” (no active output load). For capacity learning, prefer sessions where the powerbank is not simultaneously powering other devices.

+- **AirPods case:** treat as “off” **only if the earbuds are not inside** the case while charging (otherwise the case is also charging the earbuds).

+- **Apple Watch:** cannot be reliably powered down for charging; treat as **always on**.

+- **Garmin Edge bike computers / some Garmin watches:** treat as **chargeable only while off** (they need to be powered down to charge).

+- `Charging While Off.md`

+  Definition + measurement implications for capacity estimation.

+		D28F11413C8E4A7A00A10051 /* MeterChargeRecordTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11423C8E4A7A00A10052 /* MeterChargeRecordTabView.swift */; };

+		D28F11433C8E4A7A00A10053 /* MeterDataGroupsTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D28F11443C8E4A7A00A10054 /* MeterDataGroupsTabView.swift */; };

+		D28F11423C8E4A7A00A10052 /* MeterChargeRecordTabView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeterChargeRecordTabView.swift; sourceTree = "<group>"; };

+		D28F11443C8E4A7A00A10054 /* MeterDataGroupsTabView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeterDataGroupsTabView.swift; sourceTree = "<group>"; };

+				D28F11453C8E4A7A00A10055 /* ChargeRecord */,

+				D28F11463C8E4A7A00A10056 /* DataGroups */,

+		D28F11453C8E4A7A00A10055 /* ChargeRecord */ = {

+			isa = PBXGroup;

+			children = (

+				D28F11423C8E4A7A00A10052 /* MeterChargeRecordTabView.swift */,

+			);

+			path = ChargeRecord;

+			sourceTree = "<group>";

+		};

+		D28F11463C8E4A7A00A10056 /* DataGroups */ = {

+			isa = PBXGroup;

+			children = (

+				D28F11443C8E4A7A00A10054 /* MeterDataGroupsTabView.swift */,

+			);

+			path = DataGroups;

+			sourceTree = "<group>";

+		};

+				D28F11413C8E4A7A00A10051 /* MeterChargeRecordTabView.swift in Sources */,

+				D28F11433C8E4A7A00A10053 /* MeterDataGroupsTabView.swift in Sources */,

+        case chargeRecord

+        case dataGroups

+            case .chargeRecord: return "gauge.with.dots.needle.50percent"

+            case .dataGroups: return "square.grid.2x2.fill"

+                                Text(title(for: tab))

+                    .accessibilityLabel(title(for: tab))

+            MeterHomeTabView(

+                size: size,

+                isLandscape: true,

+                showChargeRecordTab: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        selectedMeterTab = .chargeRecord

+                    }

+                },

+                showDataGroupsTab: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        selectedMeterTab = .dataGroups

+                    }

+                }

+            )

+        case .chargeRecord:

+            MeterChargeRecordTabView()

+        case .dataGroups:

+            MeterDataGroupsTabView()

+            MeterHomeTabView(

+                size: size,

+                isLandscape: false,

+                showChargeRecordTab: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        selectedMeterTab = .chargeRecord

+                    }

+                },

+                showDataGroupsTab: {

+                    withAnimation(.easeInOut(duration: 0.22)) {

+                        selectedMeterTab = .dataGroups

+                    }

+                }

+            )

+        case .chargeRecord:

+            MeterChargeRecordTabView()

+        case .dataGroups:

+            MeterDataGroupsTabView()

+        var tabs: [MeterTab] = [.home, .live, .chart]

+        if meter.supportsRecordingView {

+            tabs.append(.chargeRecord)

+        }

+        tabs.append(.dataGroups)

+        tabs.append(.settings)

+        return tabs

+        selectedMeterTab = availableMeterTabs.contains(restoredTab) ? restoredTab : .home

+    private func title(for tab: MeterTab) -> String {

+        switch tab {

+        case .home:

+            return "Home"

+        case .live:

+            return "Live"

+        case .chart:

+            return "Chart"

+        case .chargeRecord:

+            return "Charge Record"

+        case .dataGroups:

+            return meter.dataGroupsTitle

+        case .settings:

+            return "Settings"

+        }

+    }

+

+struct BatteryTargetNotificationEditorSheetView: View {

+//

+//  MeterChargeRecordTabView.swift

+//  USB Meter

+//

+

+import SwiftUI

+

+struct MeterChargeRecordTabView: View {

+    @EnvironmentObject private var appData: AppData

+    @EnvironmentObject private var usbMeter: Meter

+    @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

+

+    var body: some View {

+        ScrollView {

+            VStack(spacing: 16) {

+                VStack(alignment: .leading, spacing: 8) {

+                    HStack {

+                        Text("Charge Record")

+                            .font(.system(.title3, design: .rounded).weight(.bold))

+                        Spacer()

+                        Text(usbMeter.chargeRecordStatusText)

+                            .font(.caption.weight(.bold))

+                            .foregroundColor(usbMeter.chargeRecordStatusColor)

+                            .padding(.horizontal, 10)

+                            .padding(.vertical, 6)

+                            .meterCard(

+                                tint: usbMeter.chargeRecordStatusColor,

+                                fillOpacity: 0.18,

+                                strokeOpacity: 0.24,

+                                cornerRadius: 999

+                            )

+                    }

+                    Text("App-side charge accumulation based on the stop-threshold workflow.")

+                        .font(.footnote)

+                        .foregroundColor(.secondary)

+                }

+                .frame(maxWidth: .infinity)

+                .padding(18)

+                .meterCard(tint: .pink, fillOpacity: 0.18, strokeOpacity: 0.24)

+

+                chargedDeviceSection

+

+                if let activeChargeSession {

+                    chargeMonitorSection(activeChargeSession)

+                }

+

+                ChargeRecordMetricsTableView(

+                    labels: ["Capacity", "Energy", "Duration", "Stop Threshold"],

+                    values: [

+                        "\(usbMeter.chargeRecordAH.format(decimalDigits: 3)) Ah",

+                        "\(usbMeter.chargeRecordWH.format(decimalDigits: 3)) Wh",

+                        usbMeter.chargeRecordDurationDescription,

+                        "\(usbMeter.chargeRecordStopThreshold.format(decimalDigits: 2)) A"

+                    ]

+                )

+                .padding(18)

+                .meterCard(tint: .pink, fillOpacity: 0.14, strokeOpacity: 0.20)

+

+                if usbMeter.chargeRecordTimeRange != nil {

+                    VStack(alignment: .leading, spacing: 12) {

+                        HStack {

+                            Text("Charge Curve")

+                                .font(.headline)

+                            Spacer()

+                            Button("Reset Graph") {

+                                usbMeter.resetChargeRecordGraph()

+                            }

+                            .foregroundColor(.red)

+                        }

+                        MeasurementChartView(timeRange: usbMeter.chargeRecordTimeRange)

+                            .environmentObject(usbMeter.measurements)

+                            .frame(minHeight: 220)

+                        Text("Reset Graph clears the current charge-record session and removes older shared samples that are no longer needed for this curve.")

+                            .font(.footnote)

+                            .foregroundColor(.secondary)

+                    }

+                    .padding(18)

+                    .meterCard(tint: .blue, fillOpacity: 0.14, strokeOpacity: 0.20)

+                }

+

+                VStack(alignment: .leading, spacing: 12) {

+                    Text("Stop Threshold")

+                        .font(.headline)

+                    Slider(value: $usbMeter.chargeRecordStopThreshold, in: 0...0.30, step: 0.01)

+                    Text("The app starts accumulating when current rises above this threshold and stops when it falls back to or below it.")

+                        .font(.footnote)

+                        .foregroundColor(.secondary)

+                    Button("Reset") {

+                        usbMeter.resetChargeRecord()

+                    }

+                    .frame(maxWidth: .infinity)

+                    .padding(.vertical, 10)

+                    .meterCard(tint: .orange, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                    .buttonStyle(.plain)

+                }

+                .padding(18)

+                .meterCard(tint: .orange, fillOpacity: 0.14, strokeOpacity: 0.20)

+

+                if usbMeter.supportsDataGroupCommands || usbMeter.recordedAH > 0 || usbMeter.recordedWH > 0 || usbMeter.recordingDuration > 0 {

+                    VStack(alignment: .leading, spacing: 12) {

+                        Text("Meter Totals")

+                            .font(.headline)

+                        ChargeRecordMetricsTableView(

+                            labels: ["Capacity", "Energy", "Duration", "Meter Threshold"],

+                            values: [

+                                "\(usbMeter.recordedAH.format(decimalDigits: 3)) Ah",

+                                "\(usbMeter.recordedWH.format(decimalDigits: 3)) Wh",

+                                usbMeter.recordingDurationDescription,

+                                usbMeter.supportsRecordingThreshold ? "\(usbMeter.recordingTreshold.format(decimalDigits: 2)) A" : "Read-only"

+                            ]

+                        )

+                        Text("These values are reported by the meter for the active data group.")

+                            .font(.footnote)

+                            .foregroundColor(.secondary)

+                        if usbMeter.supportsDataGroupCommands {

+                            Button("Reset Active Group") {

+                                usbMeter.clear()

+                            }

+                            .frame(maxWidth: .infinity)

+                            .padding(.vertical, 10)

+                            .meterCard(tint: .red, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                            .buttonStyle(.plain)

+                        }

+                    }

+                    .padding(18)

+                    .meterCard(tint: .teal, fillOpacity: 0.14, strokeOpacity: 0.20)

+                }

+            }

+            .padding()

+        }

+        .background(

+            LinearGradient(

+                colors: [.pink.opacity(0.14), Color.clear],

+                startPoint: .topLeading,

+                endPoint: .bottomTrailing

+            )

+            .ignoresSafeArea()

+        )

+        .sheet(isPresented: $chargedDeviceLibraryVisibility) {

+            ChargedDeviceLibrarySheetView(

+                visibility: $chargedDeviceLibraryVisibility,

+                meterMACAddress: usbMeter.btSerial.macAddress.description,

+                meterTint: usbMeter.color,

+                mode: .device

+            )

+            .environmentObject(appData)

+        }

+        .sheet(isPresented: $chargerLibraryVisibility) {

+            ChargedDeviceLibrarySheetView(

+                visibility: $chargerLibraryVisibility,

+                meterMACAddress: usbMeter.btSerial.macAddress.description,

+                meterTint: usbMeter.color,

+                mode: .charger

+            )

+            .environmentObject(appData)

+        }

+        .sheet(isPresented: $checkpointEditorVisibility) {

+            BatteryCheckpointEditorSheetView()

+                .environmentObject(appData)

+                .environmentObject(usbMeter)

+        }

+        .sheet(item: $editingChargedDevice) { chargedDevice in

+            ChargedDeviceEditorSheetView(

+                meterMACAddress: nil,

+                chargedDevice: chargedDevice

+            )

+            .environmentObject(appData)

+        }

+        .sheet(isPresented: $targetNotificationEditorVisibility) {

+            if let activeChargeSession {

+                BatteryTargetNotificationEditorSheetView(

+                    sessionID: activeChargeSession.id,

+                    initialTargetPercent: activeChargeSession.targetBatteryPercent

+                )

+                .environmentObject(appData)

+            }

+        }

+    }

+

+    private var selectedChargedDevice: ChargedDeviceSummary? {

+        appData.currentChargedDeviceSummary(for: usbMeter.btSerial.macAddress.description)

+    }

+

+    private var activeChargeSession: ChargeSessionSummary? {

+        appData.activeChargeSessionSummary(for: usbMeter.btSerial.macAddress.description)

+    }

+

+    private var selectedCharger: ChargedDeviceSummary? {

+        appData.currentChargerSummary(for: usbMeter.btSerial.macAddress.description)

+    }

+

+    private var chargedDeviceSection: some View {

+        VStack(alignment: .leading, spacing: 12) {

+            HStack {

+                Text("Device")

+                    .font(.headline)

+                Spacer()

+                Button("Library") {

+                    chargedDeviceLibraryVisibility = true

+                }

+            }

+

+            if let selectedChargedDevice {

+                HStack(alignment: .top, spacing: 14) {

+                    ChargedDeviceQRCodeView(

+                        qrIdentifier: selectedChargedDevice.qrIdentifier,

+                        side: 88

+                    )

+

+                    VStack(alignment: .leading, spacing: 8) {

+                        Label(selectedChargedDevice.name, systemImage: selectedChargedDevice.deviceClass.symbolName)

+                            .font(.headline)

+

+                        Text(selectedChargedDevice.deviceClass.title)

+                            .font(.caption.weight(.semibold))

+                            .foregroundColor(.secondary)

+

+                        Text(selectedChargedDevice.supportsChargingWhileOff ? "Can finish charging while off" : "Needs on-state sessions to estimate capacity carefully")

+                            .font(.caption2)

+                            .foregroundColor(.secondary)

+

+                        if selectedChargedDevice.supportedChargingModes.count == 1 {

+                            Label(

+                                "Charging via \(selectedChargedDevice.preferredChargingTransportMode.title)",

+                                systemImage: selectedChargedDevice.preferredChargingTransportMode.symbolName

+                            )

+                            .font(.caption2)

+                            .foregroundColor(.secondary)

+                        } else {

+                            Picker("Charging Type", selection: chargingTransportModeBinding(for: selectedChargedDevice)) {

+                                ForEach(selectedChargedDevice.supportedChargingModes) { chargingTransportMode in

+                                    Label(chargingTransportMode.title, systemImage: chargingTransportMode.symbolName)

+                                        .tag(chargingTransportMode)

+                                }

+                            }

+                            .pickerStyle(.segmented)

+                        }

+

+                        if let capacity = selectedChargedDevice.estimatedBatteryCapacityWh(for: effectiveChargingTransportMode(for: selectedChargedDevice)) {

+                            Text("Estimated \(effectiveChargingTransportMode(for: selectedChargedDevice).title.lowercased()) capacity: \(capacity.format(decimalDigits: 2)) Wh")

+                                .font(.caption)

+                                .foregroundColor(.secondary)

+                        } else if let capacity = selectedChargedDevice.estimatedBatteryCapacityWh {

+                            Text("Estimated capacity: \(capacity.format(decimalDigits: 2)) Wh")

+                                .font(.caption)

+                                .foregroundColor(.secondary)

+                        }

+

+                        if let minimumCurrent = selectedChargedDevice.resolvedCompletionCurrentAmps(for: effectiveChargingTransportMode(for: selectedChargedDevice)) {

+                            Text("\(effectiveChargingTransportMode(for: selectedChargedDevice).title) completion current: \(minimumCurrent.format(decimalDigits: 2)) A")

+                                .font(.caption2)

+                                .foregroundColor(.secondary)

+                        } else if let minimumCurrent = selectedChargedDevice.minimumCurrentAmps {

+                            Text("Completion current: \(minimumCurrent.format(decimalDigits: 2)) A")

+                                .font(.caption2)

+                                .foregroundColor(.secondary)

+                        }

+                    }

+

+                    Spacer(minLength: 0)

+                }

+

+                if shouldShowWirelessChargerSection(for: selectedChargedDevice) {

+                    Divider()

+

+                    VStack(alignment: .leading, spacing: 10) {

+                        HStack {

+                            Text("Wireless Charger")

+                                .font(.subheadline.weight(.semibold))

+                            Spacer()

+                            Button(selectedCharger == nil ? "Select" : "Change") {

+                                chargerLibraryVisibility = true

+                            }

+                        }

+

+                        if let selectedCharger {

+                            HStack(alignment: .top, spacing: 12) {

+                                ChargedDeviceQRCodeView(

+                                    qrIdentifier: selectedCharger.qrIdentifier,

+                                    side: 62

+                                )

+

+                                VStack(alignment: .leading, spacing: 6) {

+                                    Label(selectedCharger.name, systemImage: selectedCharger.deviceClass.symbolName)

+                                        .font(.subheadline.weight(.semibold))

+

+                                    if let chargerMaximumPowerWatts = selectedCharger.chargerMaximumPowerWatts {

+                                        Text("Max power: \(chargerMaximumPowerWatts.format(decimalDigits: 2)) W")

+                                            .font(.caption)

+                                            .foregroundColor(.secondary)

+                                    }

+

+                                    if !selectedCharger.chargerObservedVoltageSelections.isEmpty {

+                                        Text(

+                                            "Observed voltages: " + selectedCharger.chargerObservedVoltageSelections

+                                                .map { "\($0.format(decimalDigits: 1)) V" }

+                                                .joined(separator: ", ")

+                                        )

+                                        .font(.caption2)

+                                        .foregroundColor(.secondary)

+                                    }

+                                }

+                            }

+                        } else {

+                            Text("Wireless sessions need a selected charger in addition to the charged device.")

+                                .font(.caption)

+                                .foregroundColor(.secondary)

+                        }

+                    }

+                }

+

+                Button("Add Battery Checkpoint") {

+                    checkpointEditorVisibility = true

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .green, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                .buttonStyle(.plain)

+

+                Button("Edit Device") {

+                    editingChargedDevice = selectedChargedDevice

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .blue, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+                .buttonStyle(.plain)

+            } else {

+                Text("Select or create the device you are charging. New sessions, checkpoints, QR identity, capacity tracking, and curve learning are all anchored to that device.")

+                    .font(.footnote)

+                    .foregroundColor(.secondary)

+            }

+        }

+        .padding(18)

+        .meterCard(tint: .orange, fillOpacity: 0.14, strokeOpacity: 0.20)

+    }

+

+    private func chargeMonitorSection(_ activeChargeSession: ChargeSessionSummary) -> some View {

+        VStack(alignment: .leading, spacing: 12) {

+            Text("Charging Monitor")

+                .font(.headline)

+

+            ChargeRecordMetricsTableView(

+                labels: ["Source", "Energy", "Charge", "Stop Threshold"],

+                values: [

+                    activeChargeSession.sourceMode.title,

+                    "\(activeChargeSession.measuredEnergyWh.format(decimalDigits: 3)) Wh",

+                    "\(activeChargeSession.measuredChargeAh.format(decimalDigits: 3)) Ah",

+                    "\(activeChargeSession.stopThresholdAmps.format(decimalDigits: 2)) A"

+                ]

+            )

+

+            if let selectedChargedDevice,

+               let batteryPrediction = selectedChargedDevice.batteryLevelPrediction(for: activeChargeSession) {

+                VStack(alignment: .leading, spacing: 4) {

+                    Text("Predicted battery level: \(batteryPrediction.predictedPercent.format(decimalDigits: 0))%")

+                        .font(.caption.weight(.semibold))

+                    Text(

+                        "Anchored to \(batteryPrediction.anchorDescription) at \(batteryPrediction.anchorPercent.format(decimalDigits: 0))% using \(batteryPrediction.estimatedCapacityWh.format(decimalDigits: 2)) Wh estimated capacity."

+                    )

+                    .font(.caption2)

+                    .foregroundColor(.secondary)

+                }

+            }

+

+            if let targetBatteryPercent = activeChargeSession.targetBatteryPercent {

+                Text("Target notification: \(targetBatteryPercent.format(decimalDigits: 0))%")

+                    .font(.caption.weight(.semibold))

+            } else {

+                Text("No target battery notification configured.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            }

+

+            Button(activeChargeSession.targetBatteryPercent == nil ? "Set Target Notification" : "Change Target Notification") {

+                targetNotificationEditorVisibility = true

+            }

+            .frame(maxWidth: .infinity)

+            .padding(.vertical, 10)

+            .meterCard(tint: .indigo, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+            .buttonStyle(.plain)

+

+            if activeChargeSession.targetBatteryPercent != nil {

+                Button("Clear Target Notification") {

+                    _ = appData.setTargetBatteryPercent(nil, for: activeChargeSession.id)

+                }

+                .frame(maxWidth: .infinity)

+                .padding(.vertical, 10)

+                .meterCard(tint: .secondary, fillOpacity: 0.12, strokeOpacity: 0.18, cornerRadius: 14)

+                .buttonStyle(.plain)

+            }

+

+            if activeChargeSession.requiresCompletionConfirmation {

+                completionConfirmationCard(activeChargeSession)

+            }

+

+            if let capacityEstimateWh = activeChargeSession.capacityEstimateWh {

+                Text("Current \(activeChargeSession.chargingTransportMode.title.lowercased()) capacity estimate: \(capacityEstimateWh.format(decimalDigits: 2)) Wh")

+                    .font(.caption.weight(.semibold))

+            }

+

+            Label(

+                "Session charging type: \(activeChargeSession.chargingTransportMode.title)",

+                systemImage: activeChargeSession.chargingTransportMode.symbolName

+            )

+            .font(.caption)

+            .foregroundColor(.secondary)

+

+            if activeChargeSession.chargingTransportMode == .wireless {

+                if let chargerID = activeChargeSession.chargerID,

+                   let charger = appData.chargedDeviceSummary(id: chargerID) {

+                    Label("Wireless charger: \(charger.name)", systemImage: "bolt.badge.clock")

+                        .font(.caption)

+                        .foregroundColor(.secondary)

+                } else {

+                    Text("No wireless charger is currently selected for this session.")

+                        .font(.caption)

+                        .foregroundColor(.orange)

+                }

+            }

+

+            if activeChargeSession.checkpoints.isEmpty == false {

+                VStack(alignment: .leading, spacing: 8) {

+                    Text("Battery Checkpoints")

+                        .font(.subheadline.weight(.semibold))

+

+                    ForEach(activeChargeSession.checkpoints.suffix(4), 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)

+                        }

+                    }

+                }

+            }

+

+            Text("The monitor prefers the meter's offline counters when available, then blends them with live samples so reconnects do not lose the real transferred energy.")

+                .font(.footnote)

+                .foregroundColor(.secondary)

+        }

+        .padding(18)

+        .meterCard(tint: .green, fillOpacity: 0.14, strokeOpacity: 0.20)

+    }

+

+    private func completionConfirmationCard(_ activeChargeSession: ChargeSessionSummary) -> some View {

+        VStack(alignment: .leading, spacing: 10) {

+            Text("Completion Needs Confirmation")

+                .font(.subheadline.weight(.semibold))

+

+            if let contradictionPercent = activeChargeSession.completionContradictionPercent {

+                Text("Current dropped below the stop threshold, but the estimated battery level is only \(contradictionPercent.format(decimalDigits: 0))%.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            } else {

+                Text("Current dropped below the stop threshold, but the estimated battery level does not match a normal charge end.")

+                    .font(.caption)

+                    .foregroundColor(.secondary)

+            }

+

+            if let targetBatteryPercent = activeChargeSession.targetBatteryPercent {

+                Text("The active target is \(targetBatteryPercent.format(decimalDigits: 0))%.")

+                    .font(.caption2)

+                    .foregroundColor(.secondary)

+            }

+

+            Button("Finish Session") {

+                _ = appData.confirmChargeSessionCompletion(sessionID: activeChargeSession.id)

+            }

+            .frame(maxWidth: .infinity)

+            .padding(.vertical, 10)

+            .meterCard(tint: .orange, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+            .buttonStyle(.plain)

+

+            Button("Keep Monitoring") {

+                _ = appData.continueChargeSessionMonitoring(sessionID: activeChargeSession.id)

+            }

+            .frame(maxWidth: .infinity)

+            .padding(.vertical, 10)

+            .meterCard(tint: .blue, fillOpacity: 0.16, strokeOpacity: 0.22, cornerRadius: 14)

+            .buttonStyle(.plain)

+        }

+        .padding(14)

+        .meterCard(tint: .orange, fillOpacity: 0.10, strokeOpacity: 0.16, cornerRadius: 16)

+    }

+

+    private func chargingTransportModeBinding(for chargedDevice: ChargedDeviceSummary) -> Binding<ChargingTransportMode> {

+        Binding(

+            get: {

+                effectiveChargingTransportMode(for: chargedDevice)

+            },

+            set: { newValue in

+                _ = appData.setChargingTransportMode(newValue, for: usbMeter)

+            }

+        )

+    }

+

+    private func effectiveChargingTransportMode(for chargedDevice: ChargedDeviceSummary) -> ChargingTransportMode {

+        activeChargeSession?.chargingTransportMode ?? chargedDevice.preferredChargingTransportMode

+    }

+

+    private func shouldShowWirelessChargerSection(for chargedDevice: ChargedDeviceSummary) -> Bool {

+        effectiveChargingTransportMode(for: chargedDevice) == .wireless

+    }

+}

+//

+//  MeterDataGroupsTabView.swift

+//  USB Meter

+//

+

+import SwiftUI

+

+struct MeterDataGroupsTabView: View {

+    @EnvironmentObject private var usbMeter: Meter

+

+    var body: some View {

+        GeometryReader { box in

+            let columnTitles = [usbMeter.supportsDataGroupCommands ? "Group" : "Memory", "Ah"]

+                + (usbMeter.showsDataGroupEnergy ? ["Wh"] : [])

+                + (usbMeter.supportsDataGroupCommands ? ["Clear"] : [])

+            let columnWidth = (box.size.width - 60) / CGFloat(columnTitles.count)

+

+            ScrollView {

+                VStack(alignment: .leading, spacing: 14) {

+                    VStack(alignment: .leading, spacing: 8) {

+                        Text(usbMeter.dataGroupsTitle)

+                            .font(.system(.title3, design: .rounded).weight(.bold))

+                        if let hint = usbMeter.dataGroupsHint {

+                            Text(hint)

+                                .font(.footnote)

+                                .foregroundColor(.secondary)

+                        }

+                    }

+                    .padding(18)

+                    .meterCard(tint: .teal, fillOpacity: 0.18, strokeOpacity: 0.24)

+

+                    HStack(spacing: 8) {

+                        ForEach(columnTitles, id: \.self) { text in

+                            headerCell(text: text, width: columnWidth)

+                        }

+                    }

+

+                    VStack(spacing: 10) {

+                        ForEach(usbMeter.availableDataGroupIDs, id: \.self) { groupId in

+                            DataGroupRowView(

+                                id: groupId,

+                                width: columnWidth,

+                                opacity: groupId.isMultiple(of: 2) ? 0.1 : 0.2,

+                                showsCommands: usbMeter.supportsDataGroupCommands,

+                                showsEnergy: usbMeter.showsDataGroupEnergy,

+                                highlightsSelection: usbMeter.highlightsActiveDataGroup

+                            )

+                        }

+                    }

+                }

+                .padding()

+            }

+            .background(

+                LinearGradient(

+                    colors: [.teal.opacity(0.14), Color.clear],

+                    startPoint: .topLeading,

+                    endPoint: .bottomTrailing

+                )

+                .ignoresSafeArea()

+            )

+        }

+    }

+

+    private func headerCell(text: String, width: CGFloat) -> some View {

+        Text(text)

+            .font(.footnote.weight(.bold))

+            .frame(width: width)

+            .frame(minHeight: 38)

+            .foregroundColor(.secondary)

+            .meterCard(tint: .secondary, fillOpacity: 0.14, strokeOpacity: 0.20, cornerRadius: 14)

+    }

+}

+    let showChargeRecordTab: () -> Void

+    let showDataGroupsTab: () -> Void

+                    showDataGroupsTab()

+                        showChargeRecordTab()