耗电-检测

xcrun xctrace record --template 'Time Profiler' --attach <bundleId>

import MetricKit

class EnergyMetricReporter: NSObject, MXMetricManagerSubscriber {
    
    static let shared = EnergyMetricReporter()
    
    func start() {
        MXMetricManager.shared.add(self)
    }
    
    func didReceive(_ payloads: [MXMetricPayload]) {
        for payload in payloads {
            reportEnergy(payload)
        }
    }
    
    private func reportEnergy(_ payload: MXMetricPayload) {
        // 核心能效指标
        let cpuTime = payload.cpuMetrics.cumulativeCPUTime
        let fgTime = payload.applicationTimeMetrics?.cumulativeForegroundTime
        let bgTime = payload.applicationTimeMetrics?.cumulativeBackgroundTime
        let cellDown = payload.networkTransferMetrics?.cumulativeCellularDownload
        let cellUp = payload.networkTransferMetrics?.cumulativeCellularUpload
        let locTime = payload.locationActivityMetrics?.cumulativeBestAccuracyTime
        let pixelLum = payload.displayMetrics?.averagePixelLuminance?.averageMeasurement
        
        Analytics.report(name: "metric_energy", params: [
            "cpu_time_ms": cpuTime.converted(to: .milliseconds).value,
            "fg_time_s": fgTime?.converted(to: .seconds).value ?? 0,
            "bg_time_s": bgTime?.converted(to: .seconds).value ?? 0,
            "cellular_down_mb": cellDown?.converted(to: .megabytes).value ?? 0,
            "cellular_up_mb": cellUp?.converted(to: .megabytes).value ?? 0,
            "loc_best_time_s": locTime?.converted(to: .seconds).value ?? 0,
            "pixel_luminance": pixelLum?.value ?? 0,
        ])
    }
}

final class EnergySampleTimer {
    private var timer: DispatchSourceTimer?

    func start(interval: TimeInterval = 60) {
        let queue = DispatchQueue(label: "energy.sample.timer", qos: .utility)
        let timer = DispatchSource.makeTimerSource(queue: queue)
        timer.schedule(
            deadline: .now() + interval,
            repeating: interval,
            leeway: .seconds(max(5, Int(interval * 0.1)))
        )
        timer.setEventHandler {
            EnergySampler.shared.sampleIfNeeded()
        }
        timer.resume()
        self.timer = timer
    }
}

final class BatteryDrainMonitor {
    private var windowStartLevel: Float = -1
    private var windowStartTime: Date = Date()

    func beginWindow() {
        UIDevice.current.isBatteryMonitoringEnabled = true
        windowStartLevel = UIDevice.current.batteryLevel
        windowStartTime = Date()
    }

    func endWindow(scene: String) {
        guard UIDevice.current.batteryState == .unplugged else { return }
        guard windowStartLevel >= 0 else { return }

        let endLevel = UIDevice.current.batteryLevel
        let duration = Date().timeIntervalSince(windowStartTime)
        guard duration >= 5 * 60 else { return }

        let drop = max(0, windowStartLevel - endLevel) * 100
        let drainPerHour = drop / Float(duration / 3600)

        Analytics.report(name: "battery_drain_window", params: [
            "scene": scene,
            "drop_percent": drop,
            "duration_s": duration,
            "drain_per_hour": drainPerHour
        ])
    }
}

final class EnergyStateMonitor {
    init() {
        NotificationCenter.default.addObserver(
            forName: ProcessInfo.thermalStateDidChangeNotification,
            object: nil,
            queue: .main
        ) { _ in
            Self.reportEnergyState(reason: "thermal_change")
        }

        NotificationCenter.default.addObserver(
            forName: .NSProcessInfoPowerStateDidChange,
            object: nil,
            queue: .main
        ) { _ in
            Self.reportEnergyState(reason: "power_state_change")
        }
    }

    private static func reportEnergyState(reason: String) {
        Analytics.report(name: "energy_state_change", params: [
            "reason": reason,
            "thermal_state": thermalStateName(ProcessInfo.processInfo.thermalState),
            "low_power": ProcessInfo.processInfo.isLowPowerModeEnabled,
            "battery_level": UIDevice.current.batteryLevel,
            "scene": CurrentScene.name
        ])
    }

    private static func thermalStateName(_ state: ProcessInfo.ThermalState) -> String {
        switch state {
        case .nominal: return "nominal"
        case .fair: return "fair"
        case .serious: return "serious"
        case .critical: return "critical"
        @unknown default: return "unknown"
        }
    }
}

#import <mach/mach.h>

CGFloat app_cpu_usage(void) {
    kern_return_t kr;
    thread_array_t thread_list;
    mach_msg_type_number_t thread_count;
    
    kr = task_threads(mach_task_self(), &thread_list, &thread_count);
    if (kr != KERN_SUCCESS) return -1;
    
    float tot_cpu = 0;
    for (int i = 0; i < thread_count; i++) {
        thread_info_data_t thinfo;
        mach_msg_type_number_t thread_info_count = THREAD_INFO_MAX;
        kr = thread_info(thread_list[i], THREAD_BASIC_INFO,
                         (thread_info_t)thinfo, &thread_info_count);
        if (kr != KERN_SUCCESS) continue;
        
        thread_basic_info_t basic_info_th = (thread_basic_info_t)thinfo;
        if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
            tot_cpu += basic_info_th->cpu_usage / (float)TH_USAGE_SCALE * 100.0;
        }
    }
    vm_deallocate(mach_task_self(), (vm_offset_t)thread_list,
                  thread_count * sizeof(thread_t));
    return tot_cpu;
}

class CPUWatchdog {
    private var timer: DispatchSourceTimer?
    private var highCPUStart: Date?
    
    func start(threshold: CGFloat = 80, duration: TimeInterval = 3) {
        let t = DispatchSource.makeTimerSource(queue: DispatchQueue.global(qos: .utility))
        t.schedule(deadline: .now(), repeating: 1, leeway: .milliseconds(100))
        t.setEventHandler { [weak self] in
            let usage = CGFloat(app_cpu_usage())
            if usage > threshold {
                if self?.highCPUStart == nil {
                    self?.highCPUStart = Date()
                } else if Date().timeIntervalSince(self!.highCPUStart!) > duration {
                    // 抓一份主线程堆栈 + 业务上下文
                    self?.reportHighCPU(usage: usage)
                    self?.highCPUStart = nil
                }
            } else {
                self?.highCPUStart = nil
            }
        }
        t.resume()
        self.timer = t
    }
    
    private func reportHighCPU(usage: CGFloat) {
        let stack = StackCapture.captureMainThread()
        Analytics.report(name: "cpu_high", params: [
            "usage": usage,
            "stack": stack,
            "scene": CurrentScene.name
        ])
    }
}

低频采 CPU 数值
  ↓
连续超过阈值
  ↓
短时间采集 3~5 次堆栈
  ↓
相同堆栈本地去重 / 退火
  ↓
聚合后批量上报

电量：
  前台 session 开始/结束必采
  重点场景每 60~120s 采一次
  普通场景每 3~5min 采一次

CPU：
  普通场景 5s 一次
  高风险场景 1s 一次
  前台 >80% 持续 5s 触发堆栈
  后台 >30% 持续 30s 触发告警

Thermal / Low Power：
  监听系统通知，不轮询
  所有耗电事件顺带携带当前状态

网络 / 定位 / 音视频 / 传感器：
  统一封装 start-stop 生命周期
  本地聚合 30~60s 或累计 N 条后上报

#import <dlfcn.h>

void *IOKit = dlopen("/System/Library/Frameworks/IOKit.framework/IOKit", RTLD_LAZY);
typedef mach_port_t (*IORegistryEntryFromPathFunc)(mach_port_t, const io_string_t);
// ... IOPSCopyPowerSourcesInfo / IOPSGetPowerSourceDescription ...

func testFeedScrollEnergy() {
    let app = XCUIApplication()
    app.launch()
    
    measure(metrics: [
        XCTCPUMetric(),
        XCTMemoryMetric(),
        XCTStorageMetric(),
        XCTClockMetric()
    ]) {
        let feed = app.tables["FeedList"]
        for _ in 0..<10 {
            feed.swipeUp(velocity: .fast)
        }
    }
}