耗电-网络优化

10次请求，每次间隔2秒：
- Radio持续处于Connected/DRX状态 ≈ 30秒
- 实际传输时间可能只有几百ms

10次请求合并成1次:
- Radio活跃时间 ≈ 15秒（主要是尾巴）
- 节省约50%~70%的Radio能耗

// Bad: 一次性发送5个埋点
for event in events {
    APIClient.shared.post("/log", body: event.toDict())
}

// Good: 批量上报
APIClient.shared.post("/log/batch", body: ["events": events.map { $0.toDict() }])

class EventReporter {
    private var buffer: [Event] = []
    private let lock = NSLock()
    private var flushTimer: DispatchSourceTimer?
    
    init() {
        scheduleFlush()
        NotificationCenter.default.addObserver(
            forName: UIApplication.didEnterBackgroundNotification,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            self?.flush(reason: "background")
        }
    }
    
    func log(_ event: Event) {
        lock.lock(); defer { lock.unlock() }
        buffer.append(event)
        if buffer.count >= 50 {
            flush(reason: "size")
        }
    }
    
    private func scheduleFlush() {
        let t = DispatchSource.makeTimerSource(queue: .global(qos: .utility))
        t.schedule(deadline: .now() + 30, repeating: 30, leeway: .seconds(10))
        t.setEventHandler { [weak self] in self?.flush(reason: "interval") }
        t.resume()
        self.flushTimer = t
    }
    
    private func flush(reason: String) {
        lock.lock()
        let pending = buffer
        buffer.removeAll()
        lock.unlock()
        
        guard !pending.isEmpty else { return }
        APIClient.shared.post("/log/batch", body: ["events": pending])
    }
}

let config = URLSessionConfiguration.background(withIdentifier: "com.example.bg.download")
config.isDiscretionary = true                 // 允许系统选择最佳时机
config.sessionSendsLaunchEvents = true        // 完成时唤起App
config.waitsForConnectivity = true            // 网络不可用时等待
config.allowsCellularAccess = false           // 只在WiFi下下载

let session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
let task = session.downloadTask(with: url)
task.resume()

// AppDelegate
func application(_ application: UIApplication,
                 handleEventsForBackgroundURLSession identifier: String,
                 completionHandler: @escaping () -> Void) {
    BackgroundDownloadManager.shared.setCompletionHandler(completionHandler, for: identifier)
}

// Session delegate
func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
    DispatchQueue.main.async {
        BackgroundDownloadManager.shared.callCompletionHandler(for: session.configuration.identifier!)
    }
}

// 全局复用一个Session（或少数几个）
class APIClient {
    static let shared = APIClient()
    
    let session: URLSession = {
        let config = URLSessionConfiguration.default
        config.httpMaximumConnectionsPerHost = 6
        config.timeoutIntervalForRequest = 15
        return URLSession(configuration: config)
    }()
}

// Bad: 每次创建新的Session
func badRequest() {
    let session = URLSession(configuration: .default)  // 不复用
    session.dataTask(with: url).resume()
}

不同网络NAT超时：
- WiFi家用路由器：5~30分钟
- 运营商LTE NAT：约60~300秒
- 部分国产运营商：短至30秒

建议：
- 初始心跳240秒
- 若断开则二分探测，找到当前网络的最大心跳间隔
- 动态保存，减少不必要的心跳

import Network

class NetworkMonitor {
    static let shared = NetworkMonitor()
    let monitor = NWPathMonitor()
    private(set) var isWiFi = false
    private(set) var isExpensive = false
    private(set) var isConstrained = false  // 低数据模式
    
    func start() {
        monitor.pathUpdateHandler = { [weak self] path in
            self?.isWiFi = path.usesInterfaceType(.wifi)
            self?.isExpensive = path.isExpensive
            self?.isConstrained = path.isConstrained
        }
        monitor.start(queue: .global(qos: .utility))
    }
}

class RetryPolicy {
    
    func nextDelay(attempt: Int) -> TimeInterval {
        // 指数退避 + 抖动，避免同时重试
        let base = min(pow(2.0, Double(attempt)), 60)  // 2, 4, 8, 16, 32, 60
        let jitter = Double.random(in: 0...0.3) * base
        return base + jitter
    }
    
    func shouldRetry(error: Error, attempt: Int) -> Bool {
        if attempt >= 5 { return false }
        // 只对网络类错误重试，4xx业务错误不重试
        return (error as NSError).domain == NSURLErrorDomain
    }
}

let config = URLSessionConfiguration.default
config.waitsForConnectivity = true
config.timeoutIntervalForResource = 600  // 最长等10分钟

let session = URLSession(configuration: config, delegate: self, delegateQueue: nil)

extension UIImageView {
    func setURL(_ url: URL) {
        let scale = UIScreen.main.scale
        let w = Int(bounds.width * scale)
        let h = Int(bounds.height * scale)
        // 服务端按需裁剪
        let sized = url.appendingQuery("w=\(w)&h=\(h)&fmt=webp")
        Kingfisher.setImage(with: sized)
    }
}

func canPrefetch() -> Bool {
    if ProcessInfo.processInfo.isLowPowerModeEnabled { return false }
    if ProcessInfo.processInfo.thermalState != .nominal { return false }
    if !NetworkMonitor.shared.isWiFi { return false }
    if UIDevice.current.batteryLevel < 0.2, UIDevice.current.batteryState == .unplugged { return false }
    return true
}