WebView离线包

class OfflineResourceProtocol: URLProtocol {

    override class func canInit(with request: URLRequest) -> Bool {
        guard let url = request.url else { return false }
        return OfflinePackManager.shared.hasLocalResource(for: url)
    }

    override class func canonicalRequest(for request: URLRequest) -> URLRequest {
        return request
    }

    override func startLoading() {
        guard let url = request.url,
              let data = OfflinePackManager.shared.loadLocalResource(for: url) else {
            let error = NSError(domain: "OfflinePack", code: 404)
            client?.urlProtocol(self, didFailWithError: error)
            return
        }

        let mimeType = MIMETypeUtil.mimeType(for: url.pathExtension)
        let response = URLResponse(
            url: url,
            mimeType: mimeType,
            expectedContentLength: data.count,
            textEncodingName: "utf-8"
        )
        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
        client?.urlProtocol(self, didLoad: data)
        client?.urlProtocolDidFinishLoading(self)
    }

    override func stopLoading() {}
}

let cls: AnyClass = NSClassFromString("WKBrowsingContextController")!
let sel = NSSelectorFromString("registerSchemeForCustomProtocol:")
if cls.responds(to: sel) {
    _ = (cls as AnyObject).perform(sel, with: "https")
    _ = (cls as AnyObject).perform(sel, with: "http")
}
URLProtocol.registerClass(OfflineResourceProtocol.self)

extension WKWebView {
    static let httpSchemes = ["http", "https"]

    static func hookHandlesURLScheme() -> Bool {
        guard
            let originalMethod = class_getClassMethod(self, #selector(handlesURLScheme(_:))),
            let swizzledMethod = class_getClassMethod(self, #selector(swizzled_handlesURLScheme(_:))),
            let metaClass: AnyClass = object_getClass(self)
        else { return false }

        let originalIMP = method_getImplementation(originalMethod)
        let swizzledIMP = method_getImplementation(swizzledMethod)

        class_addMethod(metaClass, #selector(handlesURLScheme(_:)), originalIMP, method_getTypeEncoding(originalMethod))
        class_addMethod(metaClass, #selector(swizzled_handlesURLScheme(_:)), swizzledIMP, method_getTypeEncoding(swizzledMethod))

        guard
            let m1 = class_getClassMethod(self, #selector(handlesURLScheme(_:))),
            let m2 = class_getClassMethod(self, #selector(swizzled_handlesURLScheme(_:)))
        else { return false }
        method_exchangeImplementations(m1, m2)
        return true
    }

    @objc class func swizzled_handlesURLScheme(_ urlScheme: String) -> Bool {
        if httpSchemes.contains(urlScheme) {
            return false  // 骗过系统校验，允许注册 http/https 的 SchemeHandler
        }
        return swizzled_handlesURLScheme(urlScheme)  // 交换后实际调用原方法
    }
}

// App 启动时调用一次
WKWebView.hookHandlesURLScheme()

// SchemeHandler 实现——直接处理原始 http/https 请求
class OfflineHTTPSchemeHandler: NSObject, WKURLSchemeHandler {

    func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
        guard let url = urlSchemeTask.request.url else {
            urlSchemeTask.didFailWithError(NSError(domain: "OfflinePack", code: 400))
            return
        }

        // URL 就是原始 https://，直接查找本地离线资源
        if let localData = OfflinePackManager.shared.loadLocalResource(for: url) {
            let mimeType = MIMETypeUtil.mimeType(for: url.pathExtension)
            let response = HTTPURLResponse(
                url: url, statusCode: 200, httpVersion: "HTTP/1.1",
                headerFields: [
                    "Content-Type": mimeType,
                    "Access-Control-Allow-Origin": "*"
                ]
            )!
            urlSchemeTask.didReceive(response)
            urlSchemeTask.didReceive(localData)
            urlSchemeTask.didFinish()
        } else {
            // 未命中离线包，转发网络请求
            forwardToNetwork(urlSchemeTask: urlSchemeTask)
        }
    }

    func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
        // 取消进行中的网络请求...
    }

    private func forwardToNetwork(urlSchemeTask: WKURLSchemeTask) {
        let request = urlSchemeTask.request
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                urlSchemeTask.didFailWithError(error)
                return
            }
            if let response = response { urlSchemeTask.didReceive(response) }
            if let data = data { urlSchemeTask.didReceive(data) }
            urlSchemeTask.didFinish()
        }.resume()
    }
}

// 创建 WebView 时注册
let config = WKWebViewConfiguration()
let handler = OfflineHTTPSchemeHandler()
config.setURLSchemeHandler(handler, forURLScheme: "http")
config.setURLSchemeHandler(handler, forURLScheme: "https")
let webView = WKWebView(frame: .zero, configuration: config)
// 直接加载原始 URL，前端零改造
webView.load(URLRequest(url: URL(string: "https://www.example.com/page.html")!))

var nativeFetch = window.fetch;

window.fetch = function(url, opts) {
    var hasBody = opts && opts.method &&
        ['POST', 'PUT', 'PATCH', 'DELETE'].indexOf(opts.method.toUpperCase()) !== -1;
    if (hasBody && opts.body) {
        // 生成唯一标识
        var identifier = generateUUID();
        // 先将 body 通过 Bridge 发给 Native 暂存
        return saveBodyToNative(url, opts.body, identifier).then(function(newUrl) {
            // newUrl 已追加 identifier 参数
            return nativeFetch(newUrl, opts);
        });
    }
    return nativeFetch(url, opts);
};

function saveBodyToNative(url, body, identifier) {
    return new Promise(function(resolve) {
        var newUrl = url + (url.indexOf('?') !== -1 ? '&' : '?')
            + 'identifier=' + encodeURIComponent(identifier);
        // 序列化 body（支持 string/Blob/FormData/ArrayBuffer）
        getBodyString(body, function(serializedBody, type) {
            var callbackName = generateUUID();
            window[callbackName] = function() {
                delete window[callbackName];
                resolve(newUrl);
            };
            window.webkit.messageHandlers.passPostBody.postMessage(
                JSON.stringify({ identifier: identifier, cb: callbackName, body: serializedBody, type: type })
            );
        });
    });
}

// 注入 JS 拦截脚本
configuration.userContentController.addUserScript(WKUserScript(
    source: injectionScript,
    injectionTime: .atDocumentStart,
    forMainFrameOnly: true
))

// 注册 Bridge 接收 POST body
configuration.userContentController.add(
    PostBodyMessageHandler(schemeHandler: schemeHandler),
    name: "passPostBody"
)

func processRequestIfNeeded(_ request: URLRequest) -> URLRequest {
    var request = request
    guard
        let url = request.url,
        let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
        let identifier = components.queryItems?.first(where: { $0.name == "identifier" })?.value,
        let body = bodyDictionary.removeValue(forKey: identifier)
    else { return request }

    switch body {
    case .string(let str):
        request.httpBody = str.data(using: .utf8)
    case .base64(let base64):
        request.httpBody = Data(base64Encoded: base64)
    case .multipart(let items):
        let formData = MultipartFormData()
        for item in items {
            if item.type == "Blob", let data = Data(base64Encoded: item.value) {
                formData.append(data, withName: item.key, fileName: item.fileName, mimeType: item.mime)
            } else if let data = item.value.data(using: .utf8) {
                formData.append(data, withName: item.key)
            }
        }
        request.httpBody = try? formData.encode()
        request.setValue(formData.contentType, forHTTPHeaderField: "Content-Type")
    }
    return request
}

import GCDWebServer

class LocalServer {

    private let server = GCDWebServer()

    func start() {
        server.addDefaultHandler(forMethod: "GET", request: GCDWebServerRequest.self) {
            [weak self] request in
            return self?.handleRequest(request)
        }
        try? server.start(withPort: 8080, bonjourName: nil)
    }

    private func handleRequest(_ request: GCDWebServerRequest) -> GCDWebServerResponse? {
        let path = request.path
        guard let data = OfflinePackManager.shared.loadLocalResource(forPath: path) else {
            return GCDWebServerResponse(statusCode: 404)
        }
        let mimeType = MIMETypeUtil.mimeType(for: (path as NSString).pathExtension)
        return GCDWebServerDataResponse(data: data, contentType: mimeType)
    }
}

// 使用时 WebView 加载 localhost 地址
webView.load(URLRequest(url: URL(string: "http://localhost:8080/page.html")!))

bizA_v1 -> bizA_v2 -> bizA_v3

{
    "packages": {
        "bizA": {
            "version": 3,
            "md5": "a1b2c3d4e5f6",
            "path": "/offline/bizA/v3/",
            "updateTime": "2025-03-20T10:00:00Z"
        },
        "bizB": {
            "version": 5,
            "md5": "f6e5d4c3b2a1",
            "path": "/offline/bizB/v5/",
            "updateTime": "2025-03-19T08:30:00Z"
        }
    }
}

{
    "fromVersion": 2,
    "toVersion": 3,
    "added": ["new_page.html", "new_style.css"],
    "modified": ["index.js"],
    "deleted": ["old_page.html"],
    "files": {
        "new_page.html": { "md5": "abc123", "size": 2048 },
        "new_style.css": { "md5": "def456", "size": 512 },
        "index.js": { "md5": "ghi789", "size": 4096 }
    }
}

class DiffMerger {

    func applyDiff(basePath: String, diffManifest: DiffManifest, diffArchivePath: String) throws {
        for file in diffManifest.deleted {
            try FileManager.default.removeItem(atPath: basePath + "/" + file)
        }

        let tempDir = NSTemporaryDirectory() + UUID().uuidString
        try ZipArchive.unzip(diffArchivePath, to: tempDir)

        for file in diffManifest.added + diffManifest.modified {
            let source = tempDir + "/" + file
            let dest = basePath + "/" + file

            let destDir = (dest as NSString).deletingLastPathComponent
            try FileManager.default.createDirectory(
                atPath: destDir,
                withIntermediateDirectories: true
            )

            if FileManager.default.fileExists(atPath: dest) {
                try FileManager.default.removeItem(atPath: dest)
            }
            try FileManager.default.moveItem(atPath: source, toPath: dest)
        }

        try? FileManager.default.removeItem(atPath: tempDir)
    }
}

class PackageVerifier {

    static func verify(packageData: Data, signature: Data, publicKey: SecKey) -> Bool {
        var error: Unmanaged<CFError>?
        let result = SecKeyVerifySignature(
            publicKey,
            .rsaSignatureMessagePKCS1v15SHA256,
            packageData as CFData,
            signature as CFData,
            &error
        )
        return result
    }

    static func verifyFileIntegrity(directory: String, manifest: [String: String]) -> Bool {
        for (file, expectedMD5) in manifest {
            let filePath = directory + "/" + file
            guard let data = FileManager.default.contents(atPath: filePath) else {
                return false
            }
            let actualMD5 = data.md5String()
            if actualMD5 != expectedMD5 {
                return false
            }
        }
        return true
    }
}

class WebViewPool {

    static let shared = WebViewPool()
    private var pool: [WKWebView] = []
    private let lock = NSLock()

    func preload(count: Int = 2) {
        // WKWebView 必须在主线程创建
        DispatchQueue.main.async { [weak self] in
            guard let self = self else { return }
            for _ in 0..<count {
                let config = WKWebViewConfiguration()
                config.setURLSchemeHandler(OfflineSchemeHandler(), forURLScheme: "exampleApp")
                let webView = WKWebView(frame: .zero, configuration: config)
                webView.loadHTMLString("<html></html>", baseURL: nil)
                self.lock.lock()
                self.pool.append(webView)
                self.lock.unlock()
            }
        }
    }

    func dequeue() -> WKWebView? {
        lock.lock()
        defer { lock.unlock() }
        guard !pool.isEmpty else { return nil }
        return pool.removeFirst()
    }

    func recycle(_ webView: WKWebView) {
        webView.loadHTMLString("<html></html>", baseURL: nil)
        lock.lock()
        pool.append(webView)
        lock.unlock()
    }
}

Documents/OfflinePacks/
├── manifest.json          // 全局版本映射表
├── bizA/
│   ├── v3/
│   │   ├── index.html
│   │   ├── css/
│   │   ├── js/
│   │   └── images/
│   └── meta.json          // 包元数据
├── bizB/
│   ├── v5/
│   │   └── ...
│   └── meta.json
└── temp/                  // 下载临时目录

class StorageManager {

    private let maxStorageSize: UInt64 = 200 * 1024 * 1024 // 200MB
    private let basePath: String

    init() {
        let docs = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
        basePath = docs + "/OfflinePacks"
    }

    func cleanup() {
        let currentSize = calculateDirectorySize(basePath)
        guard currentSize > maxStorageSize else { return }

        let packages = loadAllPackageMeta().sorted { $0.lastAccessTime < $1.lastAccessTime }
        var freedSize: UInt64 = 0
        let targetFree = currentSize - maxStorageSize / 2

        for package in packages {
            guard !package.isCore else { continue }
            try? FileManager.default.removeItem(atPath: package.path)
            freedSize += package.size
            if freedSize >= targetFree { break }
        }
    }

    private func calculateDirectorySize(_ path: String) -> UInt64 {
        let enumerator = FileManager.default.enumerator(atPath: path)
        var size: UInt64 = 0
        while let file = enumerator?.nextObject() as? String {
            let fullPath = path + "/" + file
            if let attrs = try? FileManager.default.attributesOfItem(atPath: fullPath) {
                size += attrs[.size] as? UInt64 ?? 0
            }
        }
        return size
    }

    private func loadAllPackageMeta() -> [PackageMeta] {
        // 从各 bizX/meta.json 加载元数据
        return []
    }
}

let headers: [String: String] = [
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type, Authorization",
    "Content-Type": mimeType
]
let response = HTTPURLResponse(
    url: url,
    statusCode: 200,
    httpVersion: "HTTP/1.1",
    headerFields: headers
)!

if request.httpMethod == "OPTIONS" {
    let response = HTTPURLResponse(
        url: url, statusCode: 204, httpVersion: "HTTP/1.1",
        headerFields: corsHeaders
    )!
    urlSchemeTask.didReceive(response)
    urlSchemeTask.didReceive(Data())
    urlSchemeTask.didFinish()
    return
}

// 前端 Hook fetch，将 POST 请求通过 Bridge 发送
const originalFetch = window.fetch;
window.fetch = function(url, options) {
    if (options && options.method === 'POST') {
        return window.webkit.messageHandlers.networkBridge.postMessage({
            url: url,
            method: 'POST',
            headers: options.headers,
            body: options.body
        });
    }
    return originalFetch.apply(this, arguments);
};

struct MIMETypeUtil {
    private static let mimeTypes: [String: String] = [
        "html": "text/html",
        "htm": "text/html",
        "css": "text/css",
        "js": "application/javascript",
        "mjs": "application/javascript",
        "json": "application/json",
        "png": "image/png",
        "jpg": "image/jpeg",
        "jpeg": "image/jpeg",
        "gif": "image/gif",
        "svg": "image/svg+xml",
        "webp": "image/webp",
        "woff": "font/woff",
        "woff2": "font/woff2",
        "ttf": "font/ttf",
        "mp4": "video/mp4",
        "webm": "video/webm",
    ]

    static func mimeType(for ext: String) -> String {
        return mimeTypes[ext.lowercased()] ?? "application/octet-stream"
    }
}

func installPackage(zipPath: String, targetBizID: String) throws {
    let tempDir = basePath + "/temp/" + UUID().uuidString
    try ZipArchive.unzip(zipPath, to: tempDir)

    // 校验完整性
    guard verifyIntegrity(directory: tempDir) else {
        try? FileManager.default.removeItem(atPath: tempDir)
        throw OfflinePackError.integrityCheckFailed
    }

    let currentDir = basePath + "/" + targetBizID + "/current"
    let backupDir = basePath + "/" + targetBizID + "/backup"

    // 备份旧版本
    if FileManager.default.fileExists(atPath: currentDir) {
        try? FileManager.default.removeItem(atPath: backupDir)
        try FileManager.default.moveItem(atPath: currentDir, toPath: backupDir)
    }

    // 原子切换：rename 是文件系统级别的原子操作
    try FileManager.default.moveItem(atPath: tempDir, toPath: currentDir)

    // 切换成功后删除备份
    try? FileManager.default.removeItem(atPath: backupDir)
}

func syncCookies(to webView: WKWebView) {
    let cookies = HTTPCookieStorage.shared.cookies ?? []
    let script = cookies.map { "document.cookie='\($0.name)=\($0.value); path=/';" }
        .joined(separator: "\n")
    webView.evaluateJavaScript(script)
}

// 前端替换 localStorage
window.localStorage = {
    getItem: (key) => bridge.call('storage.get', { key }),
    setItem: (key, value) => bridge.call('storage.set', { key, value }),
    removeItem: (key) => bridge.call('storage.remove', { key })
};

func normalizeURL(_ url: URL) -> URL? {
    var path = url.path
    // 移除多余的斜杠
    while path.contains("//") {
        path = path.replacingOccurrences(of: "//", with: "/")
    }
    // 处理 query 参数中的 hash（前端框架常见）
    if let fragment = url.fragment, path.isEmpty || path == "/" {
        path = "/" + fragment
    }
    var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
    components?.path = path
    return components?.url
}

class SafeSchemeHandler: NSObject, WKURLSchemeHandler {

    private var activeTasks = Set<ObjectIdentifier>()
    private let lock = NSLock()

    func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
        let taskID = ObjectIdentifier(urlSchemeTask as AnyObject)
        lock.lock()
        activeTasks.insert(taskID)
        lock.unlock()

        loadResourceAsync(for: urlSchemeTask) { [weak self] data, response, error in
            guard let self = self else { return }

            self.lock.lock()
            let isActive = self.activeTasks.contains(taskID)
            self.lock.unlock()

            guard isActive else { return }

            if let error = error {
                urlSchemeTask.didFailWithError(error)
            } else {
                if let response = response { urlSchemeTask.didReceive(response) }
                if let data = data { urlSchemeTask.didReceive(data) }
                urlSchemeTask.didFinish()
            }
        }
    }

    func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
        let taskID = ObjectIdentifier(urlSchemeTask as AnyObject)
        lock.lock()
        activeTasks.remove(taskID)
        lock.unlock()
    }

    private func loadResourceAsync(
        for task: WKURLSchemeTask,
        completion: @escaping (Data?, URLResponse?, Error?) -> Void
    ) {
        guard let url = task.request.url else {
            completion(nil, nil, NSError(domain: "OfflinePack", code: -1))
            return
        }
        DispatchQueue.global().async {
            let data = OfflinePackManager.shared.loadLocalResource(for: url)
            let mimeType = MIMETypeUtil.mimeType(for: url.pathExtension)
            let response = HTTPURLResponse(
                url: url, statusCode: 200, httpVersion: "HTTP/1.1",
                headerFields: ["Content-Type": mimeType]
            )
            completion(data, response, nil)
        }
    }
}

class FallbackManager {

    private let maxRetryCount = 2

    func loadPage(bizID: String, webView: WKWebView) {
        let retryCount = getRetryCount(bizID: bizID)
        if retryCount >= maxRetryCount {
            // 超过重试次数，降级到在线模式
            loadOnline(bizID: bizID, webView: webView)
            reportOfflineFailure(bizID: bizID)
            return
        }

        loadOffline(bizID: bizID, webView: webView)
    }

    func onPageLoadFailed(bizID: String) {
        incrementRetryCount(bizID: bizID)
    }

    func onPageLoadSuccess(bizID: String) {
        resetRetryCount(bizID: bizID)
    }

    private func loadOnline(bizID: String, webView: WKWebView) {
        guard let url = URL(string: "https://h5.example.com/\(bizID)/") else { return }
        webView.load(URLRequest(url: url))
    }

    private func loadOffline(bizID: String, webView: WKWebView) {
        // 加载离线包资源
    }

    private func getRetryCount(bizID: String) -> Int { return 0 }
    private func incrementRetryCount(bizID: String) {}
    private func resetRetryCount(bizID: String) {}
    private func reportOfflineFailure(bizID: String) {}
}

extension WKWebView {

    func checkBlankScreen(completion: @escaping (Bool) -> Void) {
        let js = """
        (function() {
            var root = document.body || document.documentElement;
            if (!root) return true;
            var text = root.innerText || '';
            if (text.trim().length > 0) return false;
            var visibleElements = document.querySelectorAll(
                'img, canvas, video, svg, input, textarea, [style*="background"]'
            );
            for (var i = 0; i < visibleElements.length; i++) {
                var rect = visibleElements[i].getBoundingClientRect();
                if (rect.width > 0 && rect.height > 0) return false;
            }
            return true;
        })()
        """
        evaluateJavaScript(js) { result, _ in
            completion(result as? Bool ?? true)
        }
    }
}

// H5 页面中上报首屏时间
window.addEventListener('load', function() {
    var timing = performance.timing;
    var metrics = {
        dnsTime: timing.domainLookupEnd - timing.domainLookupStart,
        tcpTime: timing.connectEnd - timing.connectStart,
        firstByte: timing.responseStart - timing.requestStart,
        domReady: timing.domContentLoadedEventEnd - timing.navigationStart,
        loadComplete: timing.loadEventEnd - timing.navigationStart,
        isOffline: window.__OFFLINE_MODE__ || false
    };
    // 通过 Bridge 上报 Native
    window.webkit.messageHandlers.performance.postMessage(metrics);
});