🔋 EnergyKit

⭐ Difficulty: ⭐⭐ ⏱️ Est. Time: 1-2h 📂 iOS 26

가정의 에너지 사용을 추적하고 최적화하는 프레임워크

iOS 18+🆕 2024

✨ EnergyKit is?

EnergyKit is a framework introduced in iOS 18 that tracks and analyzes home energy usage in real-time. Integrated with HomeKit, it collects data from smart plugs, power meters, solar panels and other energy devices, providing users with power consumption patterns, renewable energy production, and saving tips. An energy management solution that supports both environmental protection and electricity cost reduction.

💡 Key Features: Real-Time Power Tracking · Renewable Energy Monitoring · Per-Device Usage · Pattern Prediction · HomeKit Integration · Energy Saving Tips · Carbon Footprint

🎯 1. Basic Setup

EnergyKit을 초기화하고 권한을 요청.

EnergyManager.swift — Basic Setup

import SwiftUI
import HomeKit

// 에너지 관리자
@Observable
class EnergyManager: NSObject {
    var homeManager = HMHomeManager()
    var currentHome: HMHome?
    var energyDevices: [EnergyDevice] = []
    var isAuthorized = false

    override init() {
        super.init()
        homeManager.delegate = self
    }

    // HomeKit 권한 확인
    func checkAuthorization() async -> Bool {
        // HomeKit은 자동으로 권한 요청
        await MainActor.run {
            isAuthorized = homeManager.authorizationStatus == .authorized
        }
        return isAuthorized
    }

    // 에너지 기기 검색
    func discoverEnergyDevices() {
        guard let home = homeManager.primaryHome else { return }

        currentHome = home
        energyDevices = []

        // 전력 측정 기능이 있는 기기 필터링
        for accessory in home.accessories {
            for service in accessory.services {
                // 전력 측정 특성 확인
                if service.characteristics.contains(where: {
                    $0.characteristicType == HMCharacteristicTypePowerState
                }) {
                    let device = EnergyDevice(
                        id: accessory.uniqueIdentifier,
                        name: accessory.name,
                        room: accessory.room?.name ?? "알 수 없음",
                        accessory: accessory
                    )
                    energyDevices.append(device)
                }
            }
        }
    }
}

// HomeKit 델리게이트
extension EnergyManager: HMHomeManagerDelegate {
    func homeManagerDidUpdateHomes(_ manager: HMHomeManager) {
        discoverEnergyDevices()
    }
}

// 에너지 기기 모델
struct EnergyDevice: Identifiable {
    let id: UUID
    let name: String
    let room: String
    let accessory: HMAccessory
    var currentPower: Double = 0 // Watts
    var todayEnergy: Double = 0 // kWh
}

⚡ 2. 실시간 전력 모니터링

현재 전력 소비량을 실시간으로 확인.

RealTimePowerView.swift — Real-Time Monitoring

import SwiftUI
import Charts

struct PowerReading: Identifiable {
    let id = UUID()
    let timestamp: Date
    let power: Double // Watts
}

@Observable
class PowerMonitor {
    var currentPower: Double = 0
    var readings: [PowerReading] = []
    private var timer: Timer?

    // 실시간 모니터링 시작
    func startMonitoring() {
        timer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { _ in
            Task { @MainActor in
                await self.updatePowerReading()
            }
        }
    }

    // 모니터링 중지
    func stopMonitoring() {
        timer?.invalidate()
        timer = nil
    }

    // 전력 측정
    func updatePowerReading() async {
        // 실제로는 HomeKit에서 데이터 읽기
        let power = Double.random(in: 500...2000)

        currentPower = power
        readings.append(PowerReading(timestamp: Date(), power: power))

        // 최근 1시간 데이터만 유지
        let oneHourAgo = Date().addingTimeInterval(-3600)
        readings.removeAll { $0.timestamp < oneHourAgo }
    }

    var averagePower: Double {
        guard !readings.isEmpty else { return 0 }
        return readings.map { $0.power }.reduce(0, +) / Double(readings.count)
    }
}

struct RealTimePowerView: View {
    @State private var monitor = PowerMonitor()

    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                // 현재 전력
                VStack {
                    Text("현재 사용량")
                        .font(.headline)
                        .foregroundStyle(.secondary)

                    HStack(alignment: .firstTextBaseline, spacing: 4) {
                        Text("\(Int(monitor.currentPower))")
                            .font(.system(size: 60, weight: .bold))
                            .contentTransition(.numericText())

                        Text("W")
                            .font(.title)
                            .foregroundStyle(.secondary)
                    }

                    Text("평균 \(Int(monitor.averagePower))W")
                        .font(.subheadline)
                        .foregroundStyle(.secondary)
                }
                .padding()
                .background(Color.blue.opacity(0.1))
                .cornerRadius(16)

                // 실시간 차트
                VStack(alignment: .leading) {
                    Text("최근 1시간")
                        .font(.headline)

                    Chart(monitor.readings) { reading in
                        LineMark(
                            x: .value("시간", reading.timestamp),
                            y: .value("전력", reading.power)
                        )
                        .foregroundStyle(.blue)
                        .interpolationMethod(.catmullRom)

                        AreaMark(
                            x: .value("시간", reading.timestamp),
                            y: .value("전력", reading.power)
                        )
                        .foregroundStyle(.blue.opacity(0.2))
                        .interpolationMethod(.catmullRom)
                    }
                    .frame(height: 200)
                    .chartYAxis {
                        AxisMarks { value in
                            AxisValueLabel {
                                if let power = value.as(Double.self) {
                                    Text("\(Int(power))W")
                                }
                            }
                        }
                    }
                }

                // 비용 추정
                HStack {
                    VStack(alignment: .leading) {
                        Text("시간당 비용")
                            .font(.caption)
                            .foregroundStyle(.secondary)

                        Text("\(estimatedHourlyCost)원")
                            .font(.title3)
                            .fontWeight(.semibold)
                    }

                    Spacer()

                    VStack(alignment: .trailing) {
                        Text("월 예상 비용")
                            .font(.caption)
                            .foregroundStyle(.secondary)

                        Text("\(estimatedMonthlyCost)원")
                            .font(.title3)
                            .fontWeight(.semibold)
                    }
                }
                .padding()
                .background(Color.gray.opacity(0.1))
                .cornerRadius(12)
            }
            .padding()
        }
        .navigationTitle("전력 모니터")
        .onAppear {
            monitor.startMonitoring()
        }
        .onDisappear {
            monitor.stopMonitoring()
        }
    }

    // 전기 요금 계산 (kWh당 300원 가정)
    var estimatedHourlyCost: Int {
        Int(monitor.currentPower / 1000 * 300)
    }

    var estimatedMonthlyCost: Int {
        estimatedHourlyCost * 24 * 30
    }
}

📊 3. 기기별 사용량 분석

각 기기의 에너지 소비를 분석하고 비교.

DeviceAnalysisView.swift — Per-Device Analysis

import SwiftUI
import Charts

struct DeviceEnergyData: Identifiable {
    let id = UUID()
    let deviceName: String
    let energy: Double // kWh
    let percentage: Double
    let category: DeviceCategory
}

enum DeviceCategory: String, CaseIterable {
    case lighting = "조명"
    case hvac = "냉난방"
    case appliance = "가전제품"
    case entertainment = "엔터테인먼트"
    case other = "기타"

    var color: Color {
        switch self {
        case .lighting: return .yellow
        case .hvac: return .blue
        case .appliance: return .green
        case .entertainment: return .purple
        case .other: return .gray
        }
    }
}

struct DeviceAnalysisView: View {
    @State private var devices: [DeviceEnergyData] = [
        .init(deviceName: "거실 에어컨", energy: 45.2, percentage: 35, category: .hvac),
        .init(deviceName: "냉장고", energy: 28.5, percentage: 22, category: .appliance),
        .init(deviceName: "조명", energy: 18.7, percentage: 15, category: .lighting),
        .init(deviceName: "TV", energy: 15.3, percentage: 12, category: .entertainment),
        .init(deviceName: "세탁기", energy: 12.8, percentage: 10, category: .appliance),
        .init(deviceName: "기타", energy: 8.5, percentage: 6, category: .other)
    ]

    var totalEnergy: Double {
        devices.map { $0.energy }.reduce(0, +)
    }

    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                // 총 사용량
                VStack {
                    Text("이번 달 총 사용량")
                        .font(.headline)
                        .foregroundStyle(.secondary)

                    HStack(alignment: .firstTextBaseline) {
                        Text("\(totalEnergy, specifier: "%.1f")")
                            .font(.system(size: 48, weight: .bold))
                        Text("kWh")
                            .font(.title2)
                            .foregroundStyle(.secondary)
                    }
                }

                // 원형 차트
                Chart(devices) { device in
                    SectorMark(
                        angle: .value("에너지", device.energy),
                        innerRadius: .ratio(0.6),
                        angularInset: 2
                    )
                    .foregroundStyle(device.category.color)
                    .annotation(position: .overlay) {
                        Text("\(Int(device.percentage))%")
                            .font(.caption)
                            .fontWeight(.bold)
                    }
                }
                .frame(height: 250)

                // 기기 목록
                VStack(alignment: .leading, spacing: 12) {
                    Text("기기별 상세")
                        .font(.headline)

                    ForEach(devices) { device in
                        HStack {
                            Circle()
                                .fill(device.category.color)
                                .frame(width: 12, height: 12)

                            VStack(alignment: .leading, spacing: 2) {
                                Text(device.deviceName)
                                    .font(.subheadline)
                                Text(device.category.rawValue)
                                    .font(.caption)
                                    .foregroundStyle(.secondary)
                            }

                            Spacer()

                            VStack(alignment: .trailing, spacing: 2) {
                                Text("\(device.energy, specifier: "%.1f") kWh")
                                    .font(.subheadline)
                                    .fontWeight(.semibold)

                                Text("\(Int(device.percentage))%")
                                    .font(.caption)
                                    .foregroundStyle(.secondary)
                            }
                        }
                        .padding()
                        .background(Color.gray.opacity(0.05))
                        .cornerRadius(8)
                    }
                }

                // 절약 팁
                VStack(alignment: .leading, spacing: 12) {
                    Label("절약 팁", systemImage: "lightbulb.fill")
                        .font(.headline)
                        .foregroundStyle(.orange)

                    Text("에어컨 설정 온도를 1도 올리면 월 약 6% 절약할 수 있습니다.")
                        .font(.subheadline)
                }
                .padding()
                .background(Color.orange.opacity(0.1))
                .cornerRadius(12)
            }
            .padding()
        }
        .navigationTitle("기기별 사용량")
    }
}

☀️ 4. 재생 에너지 모니터링

태양광 패널 등 재생 에너지 생산량을 추적.

SolarEnergyView.swift — Renewable Energy

import SwiftUI
import Charts

struct SolarData: Identifiable {
    let id = UUID()
    let hour: Int
    let production: Double // kWh
    let consumption: Double // kWh
}

@Observable
class SolarEnergyManager {
    var todayProduction: Double = 18.5
    var todayConsumption: Double = 22.3
    var gridExport: Double = 3.2 // 판매량
    var gridImport: Double = 7.0 // 구매량

    var hourlyData: [SolarData] = [
        .init(hour: 6, production: 0.2, consumption: 0.8),
        .init(hour: 7, production: 0.8, consumption: 1.2),
        .init(hour: 8, production: 1.5, consumption: 1.0),
        .init(hour: 9, production: 2.3, consumption: 0.9),
        .init(hour: 10, production: 3.0, consumption: 0.8),
        .init(hour: 11, production: 3.5, consumption: 1.0),
        .init(hour: 12, production: 3.8, consumption: 1.2),
        .init(hour: 13, production: 3.4, consumption: 1.5),
        .init(hour: 14, production: 2.8, consumption: 1.3),
        .init(hour: 15, production: 2.0, consumption: 1.8),
        .init(hour: 16, production: 1.2, consumption: 2.5),
        .init(hour: 17, production: 0.5, consumption: 3.2)
    ]

    var selfSufficiencyRate: Double {
        (todayProduction / todayConsumption) * 100
    }
}

struct SolarEnergyView: View {
    @State private var manager = SolarEnergyManager()

    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                // 오늘 요약
                HStack(spacing: 12) {
                    VStack {
                        Image(systemName: "sun.max.fill")
                            .font(.title)
                            .foregroundStyle(.orange)

                        Text("생산")
                            .font(.caption)
                            .foregroundStyle(.secondary)

                        Text("\(manager.todayProduction, specifier: "%.1f") kWh")
                            .font(.headline)
                    }
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(Color.orange.opacity(0.1))
                    .cornerRadius(12)

                    VStack {
                        Image(systemName: "bolt.fill")
                            .font(.title)
                            .foregroundStyle(.blue)

                        Text("사용")
                            .font(.caption)
                            .foregroundStyle(.secondary)

                        Text("\(manager.todayConsumption, specifier: "%.1f") kWh")
                            .font(.headline)
                    }
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(Color.blue.opacity(0.1))
                    .cornerRadius(12)
                }

                // 자급률
                VStack {
                    Text("에너지 자급률")
                        .font(.headline)

                    ZStack {
                        Circle()
                            .stroke(Color.gray.opacity(0.2), lineWidth: 20)

                        Circle()
                            .trim(from: 0, to: manager.selfSufficiencyRate / 100)
                            .stroke(
                                LinearGradient(
                                    colors: [.green, .yellow],
                                    startPoint: .leading,
                                    endPoint: .trailing
                                ),
                                style: StrokeStyle(lineWidth: 20, lineCap: .round)
                            )
                            .rotationEffect(.degrees(-90))
                            .animation(.easeInOut, value: manager.selfSufficiencyRate)

                        VStack {
                            Text("\(Int(manager.selfSufficiencyRate))%")
                                .font(.system(size: 42, weight: .bold))
                            Text("자급률")
                                .font(.caption)
                                .foregroundStyle(.secondary)
                        }
                    }
                    .frame(width: 200, height: 200)
                }

                // 시간별 차트
                VStack(alignment: .leading) {
                    Text("시간별 생산/소비")
                        .font(.headline)

                    Chart {
                        ForEach(manager.hourlyData) { data in
                            // 생산량
                            BarMark(
                                x: .value("시간", data.hour),
                                y: .value("생산", data.production)
                            )
                            .foregroundStyle(.orange)
                            .position(by: .value("타입", "생산"))

                            // 소비량
                            BarMark(
                                x: .value("시간", data.hour),
                                y: .value("소비", data.consumption)
                            )
                            .foregroundStyle(.blue)
                            .position(by: .value("타입", "소비"))
                        }
                    }
                    .frame(height: 200)
                    .chartXAxis {
                        AxisMarks { value in
                            AxisValueLabel {
                                if let hour = value.as(Int.self) {
                                    Text("\(hour)시")
                                }
                            }
                        }
                    }
                }

                // 전력망 거래
                VStack(alignment: .leading, spacing: 12) {
                    Text("전력망 거래")
                        .font(.headline)

                    HStack {
                        Label("판매", systemImage: "arrow.up.circle.fill")
                            .foregroundStyle(.green)
                        Spacer()
                        Text("\(manager.gridExport, specifier: "%.1f") kWh")
                            .fontWeight(.semibold)
                    }

                    HStack {
                        Label("구매", systemImage: "arrow.down.circle.fill")
                            .foregroundStyle(.red)
                        Spacer()
                        Text("\(manager.gridImport, specifier: "%.1f") kWh")
                            .fontWeight(.semibold)
                    }
                }
                .padding()
                .background(Color.gray.opacity(0.05))
                .cornerRadius(12)

                // 환경 영향
                VStack(alignment: .leading, spacing: 8) {
                    Label("환경 기여도", systemImage: "leaf.fill")
                        .font(.headline)
                        .foregroundStyle(.green)

                    Text("오늘 \(carbonReduction)kg의 CO₂ 배출을 줄였습니다")
                        .font(.subheadline)

                    Text("나무 \(treesEquivalent)그루 심은 효과")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
                .padding()
                .background(Color.green.opacity(0.1))
                .cornerRadius(12)
            }
            .padding()
        }
        .navigationTitle("태양광 에너지")
    }

    // CO2 절감량 (kWh당 약 0.46kg)
    var carbonReduction: Double {
        manager.todayProduction * 0.46
    }

    // 나무 환산 (나무 1그루는 연간 약 6kg CO2 흡수)
    var treesEquivalent: Int {
        Int(carbonReduction / 6 * 365)
    }
}

📈 5. 사용 패턴 분석

Analyze energy usage patterns and provide optimization suggestions.

UsagePatternView.swift — Pattern Analysis

import SwiftUI
import Charts

struct DailyUsage: Identifiable {
    let id = UUID()
    let date: Date
    let energy: Double
    let cost: Double
}

@Observable
class UsagePatternAnalyzer {
    var weeklyData: [DailyUsage] = []
    var peakHour: Int = 19 // 오후 7시
    var recommendations: [String] = []

    init() {
        generateWeeklyData()
        analyzePattern()
    }

    func generateWeeklyData() {
        let calendar = Calendar.current
        for day in 0.<7 {
            let date = calendar.date(byAdding: .day, value: -day, to: Date())!
            let energy = Double.random(in: 15...30)
            let cost = energy * 300 // kWh당 300원

            weeklyData.insert(
                DailyUsage(date: date, energy: energy, cost: cost),
                at: 0
            )
        }
    }

    func analyzePattern() {
        // 패턴 분석 및 추천
        recommendations = [
            "오후 7-9시에 사용량이 가장 높습니다. 세탁기는 심야 시간에 사용하세요.",
            "평균보다 20% 많이 사용하고 있습니다. 대기전력을 차단하세요.",
            "냉난방 설정 온도를 조절하면 월 15,000원 절약할 수 있습니다."
        ]
    }

    var averageDaily: Double {
        weeklyData.map { $0.energy }.reduce(0, +) / Double(weeklyData.count)
    }

    var estimatedMonthlyCost: Double {
        averageDaily * 30 * 300
    }
}

struct UsagePatternView: View {
    @State private var analyzer = UsagePatternAnalyzer()

    var body: some View {
        ScrollView {
            VStack(spacing: 24) {
                // 주간 추이
                VStack(alignment: .leading) {
                    Text("주간 사용 추이")
                        .font(.headline)

                    Chart(analyzer.weeklyData) { usage in
                        BarMark(
                            x: .value("날짜", usage.date, unit: .day),
                            y: .value("에너지", usage.energy)
                        )
                        .foregroundStyle(
                            LinearGradient(
                                colors: [.blue, .cyan],
                                startPoint: .top,
                                endPoint: .bottom
                            )
                        )

                        RuleMark(y: .value("평균", analyzer.averageDaily))
                            .foregroundStyle(.red)
                            .lineStyle(StrokeStyle(lineWidth: 2, dash: [5]))
                            .annotation(position: .top, alignment: .trailing) {
                                Text("평균")
                                    .font(.caption)
                                    .foregroundStyle(.red)
                            }
                    }
                    .frame(height: 200)
                    .chartXAxis {
                        AxisMarks { value in
                            AxisValueLabel(format: .dateTime.weekday(.narrow))
                        }
                    }
                }

                // 통계
                HStack(spacing: 12) {
                    VStack {
                        Text("일평균")
                            .font(.caption)
                            .foregroundStyle(.secondary)
                        Text("\(analyzer.averageDaily, specifier: "%.1f")")
                            .font(.title2)
                            .fontWeight(.bold)
                        Text("kWh")
                            .font(.caption)
                    }
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(Color.blue.opacity(0.1))
                    .cornerRadius(12)

                    VStack {
                        Text("월예상")
                            .font(.caption)
                            .foregroundStyle(.secondary)
                        Text("\(Int(analyzer.estimatedMonthlyCost))")
                            .font(.title2)
                            .fontWeight(.bold)
                        Text("원")
                            .font(.caption)
                    }
                    .frame(maxWidth: .infinity)
                    .padding()
                    .background(Color.green.opacity(0.1))
                    .cornerRadius(12)
                }

                // 피크 타임
                VStack(alignment: .leading, spacing: 8) {
                    Label("최대 사용 시간", systemImage: "clock.fill")
                        .font(.headline)

                    Text("오후 \(analyzer.peakHour - 12)시")
                        .font(.title3)
                        .fontWeight(.semibold)
                        .foregroundStyle(.blue)

                    Text("전기 요금이 저렴한 심야 시간(오후 11시~오전 9시)에 고전력 기기를 사용하세요.")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
                .padding()
                .background(Color.gray.opacity(0.05))
                .cornerRadius(12)

                // 추천 사항
                VStack(alignment: .leading, spacing: 16) {
                    Label("맞춤 추천", systemImage: "sparkles")
                        .font(.headline)

                    ForEach(Array(analyzer.recommendations.enumerated()), id: \.0) { index, tip in
                        HStack(alignment: .top, spacing: 12) {
                            Text("\(index + 1)")
                                .font(.caption)
                                .fontWeight(.bold)
                                .foregroundStyle(.white)
                                .frame(width: 24, height: 24)
                                .background(Color.blue)
                                .clipShape(Circle())

                            Text(tip)
                                .font(.subheadline)
                        }
                    }
                }
                .padding()
                .background(Color.blue.opacity(0.05))
                .cornerRadius(12)
            }
            .padding()
        }
        .navigationTitle("사용 패턴 분석")
    }
}

💡 HIG Guidelines

Privacy: 에너지 데이터는 민감 정보이므로 온디바이스에서 처리
실시간 업데이트: 현재 전력 소비를 5-10초 간격으로 업데이트
명확한 시각화: 차트와 그래프로 이해하기 쉽게 표시
실용적인 팁: 실제로 실천 가능한 절약 방법 제안
HomeKit 통합: 기존 HomeKit 기기와 원활하게 연동

🎯 Practical Usage

스마트홈 앱: 전체 가정의 에너지 대시보드
태양광 모니터링: 재생 에너지 생산량 추적
에너지 절약 챌린지: 게이미피케이션으로 절약 유도
부동산 관리: 건물 에너지 효율 모니터링
환경 앱: 탄소 발자국 계산 및 감소

📚 Learn More

⚡️ Performance Tips: EnergyKit leverages HomeKit infrastructure, so it works without a separate hub. Power measurement data updates every 5 seconds, but use smooth animations for better UX. Store large history data locally with CoreData or SwiftData, and sync to iCloud as needed. Energy saving tips can be personalized using machine learning to learn usage patterns.

📎 Apple Official Resources

📘 Documentation 🎬 WWDC Sessions