@capgo/capacitor-network-diagnostics 8.0.1

package/ios/Sources/NetworkDiagnosticsPlugin/NetworkDiagnostics+Run.swift

@@ -0,0 +1,163 @@
+import Foundation
+
+extension NetworkDiagnostics {
+    public func runDiagnostics(
+        urls: [[String: Any]],
+        ports: [[String: Any]],
+        websockets: [[String: Any]],
+        download: [String: Any]?,
+        packetLoss: [String: Any]?
+    ) async -> [String: Any] {
+        let status = await getNetworkStatus()
+        var issues = statusIssues(status)
+        let urlDiagnostics = await runUrlDiagnostics(urls)
+        let portDiagnostics = await runPortDiagnostics(ports)
+        let websocketDiagnostics = await runWebSocketDiagnostics(websockets)
+        var output: [String: Any] = ["status": status]
+
+        output["urls"] = urlDiagnostics.results
+        output["ports"] = portDiagnostics.results
+        output["websockets"] = websocketDiagnostics.results
+        issues += urlDiagnostics.issues + portDiagnostics.issues + websocketDiagnostics.issues
+
+        if let downloadResult = await downloadDiagnostic(download) {
+            output["download"] = downloadResult.result
+            issues += downloadResult.issues
+        }
+
+        if let packetLossResult = await packetLossDiagnostic(packetLoss) {
+            output["packetLoss"] = packetLossResult.result
+            issues += packetLossResult.issues
+        }
+
+        output["issues"] = issues
+        return output
+    }
+
+    func runUrlDiagnostics(_ urls: [[String: Any]]) async -> DiagnosticGroupResult {
+        var results: [[String: Any]] = []
+        var issues: [String] = []
+        for options in urls {
+            let result = await testUrl(
+                url: options["url"] as? String ?? "",
+                method: options["method"] as? String ?? "HEAD",
+                timeoutMs: options["timeoutMs"] as? Int ?? 10_000,
+                followRedirects: options["followRedirects"] as? Bool ?? true
+            )
+            results.append(result)
+            appendUrlIssue(result, to: &issues)
+        }
+        return DiagnosticGroupResult(results: results, issues: issues)
+    }
+
+    func runPortDiagnostics(_ ports: [[String: Any]]) async -> DiagnosticGroupResult {
+        var results: [[String: Any]] = []
+        var issues: [String] = []
+        for options in ports {
+            let result = await testPort(
+                host: options["host"] as? String ?? "",
+                port: options["port"] as? Int ?? 0,
+                timeoutMs: options["timeoutMs"] as? Int ?? 5_000
+            )
+            results.append(result)
+            appendPortIssue(result, to: &issues)
+        }
+        return DiagnosticGroupResult(results: results, issues: issues)
+    }
+
+    func runWebSocketDiagnostics(_ websockets: [[String: Any]]) async -> DiagnosticGroupResult {
+        var results: [[String: Any]] = []
+        var issues: [String] = []
+        for options in websockets {
+            let result = await testWebSocket(
+                url: options["url"] as? String ?? "",
+                timeoutMs: options["timeoutMs"] as? Int ?? 10_000
+            )
+            results.append(result)
+            appendWebSocketIssue(result, to: &issues)
+        }
+        return DiagnosticGroupResult(results: results, issues: issues)
+    }
+
+    func downloadDiagnostic(_ download: [String: Any]?) async -> OptionalDiagnosticResult? {
+        guard let download = download else {
+            return nil
+        }
+
+        let result = await testDownloadSpeed(
+            url: download["url"] as? String ?? "",
+            maxBytes: download["maxBytes"] as? Int ?? 5 * 1024 * 1024,
+            timeoutMs: download["timeoutMs"] as? Int ?? 30_000
+        )
+        var issues: [String] = []
+        if !(result["ok"] as? Bool ?? false) {
+            issues.append("Download speed test failed: \(result["url"] as? String ?? "")")
+        }
+        return OptionalDiagnosticResult(result: result, issues: issues)
+    }
+
+    func packetLossDiagnostic(_ packetLoss: [String: Any]?) async -> OptionalDiagnosticResult? {
+        guard let packetLoss = packetLoss else {
+            return nil
+        }
+
+        let result = await testPacketLoss(packetLossOptions(from: packetLoss))
+        var issues: [String] = []
+        if let lossPercent = result["lossPercent"] as? Double, lossPercent > 0 {
+            issues.append("Packet loss detected: \(lossPercent)% to \(result["target"] as? String ?? "")")
+        }
+        return OptionalDiagnosticResult(result: result, issues: issues)
+    }
+
+    func packetLossOptions(from options: [String: Any]) -> PacketLossOptions {
+        PacketLossOptions(
+            mode: options["mode"] as? String ?? "",
+            host: options["host"] as? String ?? "",
+            port: options["port"] as? Int ?? 0,
+            url: options["url"] as? String ?? "",
+            count: options["count"] as? Int ?? 10,
+            timeoutMs: options["timeoutMs"] as? Int ?? 3_000,
+            intervalMs: options["intervalMs"] as? Int ?? 250
+        )
+    }
+
+    func statusIssues(_ status: [String: Any]) -> [String] {
+        if !(status["connected"] as? Bool ?? false) {
+            return ["No active network connection"]
+        }
+        if !(status["internetReachable"] as? Bool ?? false) {
+            return ["Network is connected but internet reachability is not confirmed"]
+        }
+        return []
+    }
+
+    func appendUrlIssue(_ result: [String: Any], to issues: inout [String]) {
+        if !(result["reachable"] as? Bool ?? false) {
+            issues.append("URL unreachable: \(result["url"] as? String ?? "")")
+        } else if !(result["ok"] as? Bool ?? false) {
+            issues.append("URL returned non-success status: \(result["url"] as? String ?? "")")
+        }
+    }
+
+    func appendPortIssue(_ result: [String: Any], to issues: inout [String]) {
+        if !(result["open"] as? Bool ?? false) {
+            issues.append("TCP port blocked or unreachable: \(result["host"] as? String ?? ""):\(result["port"] as? Int ?? 0)")
+        }
+    }
+
+    func appendWebSocketIssue(_ result: [String: Any], to issues: inout [String]) {
+        if !(result["open"] as? Bool ?? false) {
+            issues.append("WebSocket failed: \(result["url"] as? String ?? "")")
+        }
+    }
+}
+
+struct DiagnosticGroupResult {
+    let results: [[String: Any]]
+    let issues: [String]
+}
+
+struct OptionalDiagnosticResult {
+    let result: [String: Any]
+    let issues: [String]
+}

package/ios/Sources/NetworkDiagnosticsPlugin/NetworkDiagnostics+Utils.swift

@@ -0,0 +1,202 @@
+import Foundation
+import Network
+
+extension NetworkDiagnostics {
+    func currentPath() async -> NWPath {
+        await withCheckedContinuation { continuation in
+            let monitor = NWPathMonitor()
+            let queue = DispatchQueue(label: "app.capgo.networkdiagnostics.path")
+            var resumed = false
+
+            func resume(with path: NWPath) {
+                if resumed {
+                    return
+                }
+                resumed = true
+                monitor.cancel()
+                continuation.resume(returning: path)
+            }
+
+            monitor.pathUpdateHandler = { path in
+                resume(with: path)
+            }
+            monitor.start(queue: queue)
+            queue.asyncAfter(deadline: .now() + 1) {
+                resume(with: monitor.currentPath)
+            }
+        }
+    }
+
+    func probeTcp(host: String, port: Int, timeoutMs: Int) async -> ProbeResult {
+        let started = Date()
+        guard let nwPort = NWEndpoint.Port(rawValue: UInt16(port)) else {
+            return ProbeResult(success: false, durationMs: elapsedMs(started), errorCode: "INVALID_PORT", errorMessage: "Invalid port")
+        }
+
+        let connection = NWConnection(host: NWEndpoint.Host(host), port: nwPort, using: .tcp)
+
+        return await withCheckedContinuation { continuation in
+            let queue = DispatchQueue(label: "app.capgo.networkdiagnostics.tcp")
+            var finished = false
+
+            func finish(success: Bool, error: Error?) {
+                if finished {
+                    return
+                }
+                finished = true
+                connection.cancel()
+                continuation.resume(
+                    returning: ProbeResult(
+                        success: success,
+                        durationMs: elapsedMs(started),
+                        errorCode: error.map { errorCode($0) },
+                        errorMessage: error?.localizedDescription
+                    )
+                )
+            }
+
+            connection.stateUpdateHandler = { state in
+                switch state {
+                case .ready:
+                    finish(success: true, error: nil)
+                case .failed(let error):
+                    finish(success: false, error: error)
+                case .cancelled:
+                    if !finished {
+                        finish(success: false, error: NetworkDiagnosticsError.cancelled)
+                    }
+                default:
+                    break
+                }
+            }
+
+            queue.asyncAfter(deadline: .now() + timeout(timeoutMs, fallback: 5)) {
+                finish(success: false, error: NetworkDiagnosticsError.timeout)
+            }
+            connection.start(queue: queue)
+        }
+    }
+
+    func probeHttp(url: String, timeoutMs: Int) async -> ProbeResult {
+        let result = await testUrl(url: url, method: "HEAD", timeoutMs: timeoutMs, followRedirects: true)
+        let reachable = result["reachable"] as? Bool ?? false
+        return ProbeResult(
+            success: reachable,
+            durationMs: result["durationMs"] as? Int ?? 0,
+            errorCode: result["errorCode"] as? String,
+            errorMessage: result["errorMessage"] as? String
+        )
+    }
+
+    func websocketResult(_ base: [String: Any], started: Date, open: Bool, error: Error?) -> [String: Any] {
+        var output = base
+        output["open"] = open
+        output["durationMs"] = elapsedMs(started)
+        if let error = error {
+            output["errorCode"] = errorCode(error)
+            output["errorMessage"] = error.localizedDescription
+        }
+        return output
+    }
+
+    func connectionType(_ path: NWPath) -> String {
+        if path.usesInterfaceType(.wifi) {
+            return "wifi"
+        }
+        if path.usesInterfaceType(.cellular) {
+            return "cellular"
+        }
+        if path.usesInterfaceType(.wiredEthernet) {
+            return "ethernet"
+        }
+        if path.usesInterfaceType(.loopback) || path.usesInterfaceType(.other) {
+            return "other"
+        }
+        return "unknown"
+    }
+
+    func statusLabel(_ status: NWPath.Status) -> String {
+        switch status {
+        case .satisfied:
+            return "satisfied"
+        case .unsatisfied:
+            return "unsatisfied"
+        case .requiresConnection:
+            return "requiresConnection"
+        @unknown default:
+            return "unknown"
+        }
+    }
+
+    func normalizeMethod(_ method: String) -> String {
+        method.uppercased() == "GET" ? "GET" : "HEAD"
+    }
+
+    func normalizePacketLossMode(mode: String, host: String, port: Int, url: String) -> String {
+        if mode.lowercased() == "http" {
+            return "http"
+        }
+        if mode.lowercased() == "tcp" {
+            return "tcp"
+        }
+        if !host.isEmpty && port > 0 {
+            return "tcp"
+        }
+        if !url.isEmpty {
+            return "http"
+        }
+        return "tcp"
+    }
+
+    func positive(_ value: Int, fallback: Int) -> Int {
+        value > 0 ? value : fallback
+    }
+
+    func timeout(_ value: Int, fallback: TimeInterval) -> TimeInterval {
+        TimeInterval(positive(value, fallback: Int(fallback * 1000))) / 1000.0
+    }
+
+    func elapsedMs(_ started: Date) -> Int {
+        max(Int(Date().timeIntervalSince(started) * 1000), 0)
+    }
+
+    func errorCode(_ error: Error) -> String {
+        let nsError = error as NSError
+        if nsError.domain == NSURLErrorDomain {
+            return urlErrorCode(nsError.code)
+        }
+        if error is NetworkDiagnosticsError {
+            return "\(error)".uppercased()
+        }
+        return String(describing: type(of: error))
+    }
+
+    func urlErrorCode(_ code: Int) -> String {
+        switch code {
+        case NSURLErrorTimedOut:
+            return "TIMEOUT"
+        case NSURLErrorCannotFindHost, NSURLErrorDNSLookupFailed:
+            return "DNS_ERROR"
+        case NSURLErrorCannotConnectToHost, NSURLErrorNetworkConnectionLost:
+            return "CONNECTION_FAILED"
+        case NSURLErrorSecureConnectionFailed, NSURLErrorServerCertificateUntrusted:
+            return "TLS_ERROR"
+        default:
+            return "URL_ERROR_\(code)"
+        }
+    }
+}
+
+enum NetworkDiagnosticsError: Error, LocalizedError {
+    case cancelled
+    case timeout
+
+    var errorDescription: String? {
+        switch self {
+        case .cancelled:
+            return "Connection was cancelled"
+        case .timeout:
+            return "Connection timed out"
+        }
+    }
+}

package/ios/Sources/NetworkDiagnosticsPlugin/NetworkDiagnostics.swift

@@ -0,0 +1,151 @@
+import Foundation
+import Network
+
+@objc public class NetworkDiagnostics: NSObject {
+    @objc public func getPluginVersion() -> String {
+        return "native"
+    }
+
+    public func getNetworkStatus() async -> [String: Any] {
+        let path = await currentPath()
+        let connected = path.status == .satisfied
+        var details: [String: Any] = [
+            "status": statusLabel(path.status),
+            "interfaces": path.availableInterfaces.map { $0.name }.joined(separator: ",")
+        ]
+
+        if let gateway = path.gateways.first {
+            details["gateway"] = "\(gateway)"
+        }
+
+        return [
+            "connected": connected,
+            "connectionType": connected ? connectionType(path) : "none",
+            "internetReachable": connected,
+            "expensive": path.isExpensive,
+            "constrained": path.isConstrained,
+            "details": details
+        ]
+    }
+
+    public func testUrl(url: String, method: String, timeoutMs: Int, followRedirects: Bool) async -> [String: Any] {
+        let started = Date()
+        let normalizedMethod = normalizeMethod(method)
+        var result: [String: Any] = [
+            "url": url,
+            "method": normalizedMethod
+        ]
+
+        guard let parsedUrl = URL(string: url) else {
+            result["ok"] = false
+            result["reachable"] = false
+            result["durationMs"] = elapsedMs(started)
+            result["errorCode"] = "INVALID_URL"
+            result["errorMessage"] = "Invalid URL"
+            return result
+        }
+
+        var request = URLRequest(url: parsedUrl)
+        request.httpMethod = normalizedMethod
+        request.timeoutInterval = timeout(timeoutMs, fallback: 10)
+
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.timeoutIntervalForRequest = request.timeoutInterval
+        configuration.timeoutIntervalForResource = request.timeoutInterval
+        let delegate = followRedirects ? nil : NoRedirectDelegate()
+        let session = URLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)
+        defer { session.finishTasksAndInvalidate() }
+
+        do {
+            let (_, response) = try await session.data(for: request)
+            let statusCode = (response as? HTTPURLResponse)?.statusCode ?? 0
+            result["ok"] = statusCode >= 200 && statusCode < 400
+            result["reachable"] = true
+            result["durationMs"] = elapsedMs(started)
+            result["statusCode"] = statusCode
+            result["finalUrl"] = response.url?.absoluteString ?? url
+        } catch {
+            result["ok"] = false
+            result["reachable"] = false
+            result["durationMs"] = elapsedMs(started)
+            result["errorCode"] = errorCode(error)
+            result["errorMessage"] = error.localizedDescription
+        }
+
+        return result
+    }
+
+    public func testPort(host: String, port: Int, timeoutMs: Int) async -> [String: Any] {
+        let probe = await probeTcp(host: host, port: port, timeoutMs: timeoutMs)
+        var result: [String: Any] = [
+            "host": host,
+            "port": port,
+            "open": probe.success,
+            "durationMs": probe.durationMs
+        ]
+
+        if !probe.success {
+            result["errorCode"] = probe.errorCode
+            result["errorMessage"] = probe.errorMessage
+        }
+
+        return result
+    }
+
+    public func testWebSocket(url: String, timeoutMs: Int) async -> [String: Any] {
+        let started = Date()
+        var result: [String: Any] = ["url": url]
+
+        guard let parsedUrl = URL(string: url), let scheme = parsedUrl.scheme?.lowercased(), scheme == "ws" || scheme == "wss" else {
+            result["open"] = false
+            result["durationMs"] = elapsedMs(started)
+            result["errorCode"] = "INVALID_URL"
+            result["errorMessage"] = "WebSocket URL must use ws:// or wss://"
+            return result
+        }
+
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.timeoutIntervalForRequest = timeout(timeoutMs, fallback: 10)
+        configuration.timeoutIntervalForResource = timeout(timeoutMs, fallback: 10)
+        let session = URLSession(configuration: configuration)
+        let task = session.webSocketTask(with: parsedUrl)
+        task.resume()
+
+        return await withCheckedContinuation { continuation in
+            let queue = DispatchQueue(label: "app.capgo.networkdiagnostics.websocket")
+            var finished = false
+
+            func finish(open: Bool, error: Error?) {
+                if finished {
+                    return
+                }
+                finished = true
+                task.cancel(with: .goingAway, reason: nil)
+                session.invalidateAndCancel()
+                continuation.resume(returning: websocketResult(result, started: started, open: open, error: error))
+            }
+
+            queue.asyncAfter(deadline: .now() + timeout(timeoutMs, fallback: 10)) {
+                finish(open: false, error: NetworkDiagnosticsError.timeout)
+            }
+
+            task.sendPing { error in
+                queue.async {
+                    finish(open: error == nil, error: error)
+                }
+            }
+        }
+    }
+}
+
+private final class NoRedirectDelegate: NSObject, URLSessionTaskDelegate {
+    func urlSession(
+        _ session: URLSession,
+        task: URLSessionTask,
+        willPerformHTTPRedirection response: HTTPURLResponse,
+        newRequest request: URLRequest,
+        completionHandler: @escaping (URLRequest?) -> Void
+    ) {
+        completionHandler(nil)
+    }
+}

package/ios/Sources/NetworkDiagnosticsPlugin/NetworkDiagnosticsPlugin.swift

@@ -0,0 +1,139 @@
+import Foundation
+import Capacitor
+
+@objc(NetworkDiagnosticsPlugin)
+public class NetworkDiagnosticsPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "NetworkDiagnosticsPlugin"
+    public let jsName = "NetworkDiagnostics"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getNetworkStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "testUrl", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "testPort", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "testWebSocket", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "testDownloadSpeed", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "testPacketLoss", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "runDiagnostics", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
+    ]
+
+    private let implementation = NetworkDiagnostics()
+
+    @objc func getNetworkStatus(_ call: CAPPluginCall) {
+        Task {
+            call.resolve(await implementation.getNetworkStatus())
+        }
+    }
+
+    @objc func testUrl(_ call: CAPPluginCall) {
+        guard let url = call.getString("url"), !url.isEmpty else {
+            call.reject("URL is required")
+            return
+        }
+
+        Task {
+            call.resolve(await implementation.testUrl(
+                url: url,
+                method: call.getString("method") ?? "HEAD",
+                timeoutMs: call.getInt("timeoutMs") ?? 10_000,
+                followRedirects: call.getBool("followRedirects") ?? true
+            ))
+        }
+    }
+
+    @objc func testPort(_ call: CAPPluginCall) {
+        guard let host = call.getString("host"), !host.isEmpty else {
+            call.reject("Host is required")
+            return
+        }
+        let port = call.getInt("port") ?? 0
+        guard port > 0 && port <= 65_535 else {
+            call.reject("Port must be between 1 and 65535")
+            return
+        }
+
+        Task {
+            call.resolve(await implementation.testPort(
+                host: host,
+                port: port,
+                timeoutMs: call.getInt("timeoutMs") ?? 5_000
+            ))
+        }
+    }
+
+    @objc func testWebSocket(_ call: CAPPluginCall) {
+        guard let url = call.getString("url"), !url.isEmpty else {
+            call.reject("URL is required")
+            return
+        }
+
+        Task {
+            call.resolve(await implementation.testWebSocket(
+                url: url,
+                timeoutMs: call.getInt("timeoutMs") ?? 10_000
+            ))
+        }
+    }
+
+    @objc func testDownloadSpeed(_ call: CAPPluginCall) {
+        guard let url = call.getString("url"), !url.isEmpty else {
+            call.reject("URL is required")
+            return
+        }
+
+        Task {
+            call.resolve(await implementation.testDownloadSpeed(
+                url: url,
+                maxBytes: call.getInt("maxBytes") ?? 5 * 1024 * 1024,
+                timeoutMs: call.getInt("timeoutMs") ?? 30_000
+            ))
+        }
+    }
+
+    @objc func testPacketLoss(_ call: CAPPluginCall) {
+        let host = call.getString("host") ?? ""
+        let port = call.getInt("port") ?? 0
+        let url = call.getString("url") ?? ""
+
+        guard (!host.isEmpty && port > 0) || !url.isEmpty else {
+            call.reject("Either host and port, or url is required")
+            return
+        }
+
+        Task {
+            let options = PacketLossOptions(
+                mode: call.getString("mode") ?? "",
+                host: host,
+                port: port,
+                url: url,
+                count: call.getInt("count") ?? 10,
+                timeoutMs: call.getInt("timeoutMs") ?? 3_000,
+                intervalMs: call.getInt("intervalMs") ?? 250
+            )
+            call.resolve(await implementation.testPacketLoss(options))
+        }
+    }
+
+    @objc func runDiagnostics(_ call: CAPPluginCall) {
+        let urls = call.getArray("urls", []) as? [[String: Any]] ?? []
+        let ports = call.getArray("ports", []) as? [[String: Any]] ?? []
+        let websockets = call.getArray("websockets", []) as? [[String: Any]] ?? []
+        let download = call.getObject("download")
+        let packetLoss = call.getObject("packetLoss")
+
+        Task {
+            call.resolve(await implementation.runDiagnostics(
+                urls: urls,
+                ports: ports,
+                websockets: websockets,
+                download: download,
+                packetLoss: packetLoss
+            ))
+        }
+    }
+
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve([
+            "version": implementation.getPluginVersion()
+        ])
+    }
+}

package/ios/Tests/NetworkDiagnosticsPluginTests/NetworkDiagnosticsTests.swift

@@ -0,0 +1,11 @@
+import XCTest
+@testable import NetworkDiagnosticsPlugin
+
+class NetworkDiagnosticsTests: XCTestCase {
+    func testGetPluginVersion() {
+        let implementation = NetworkDiagnostics()
+        let result = implementation.getPluginVersion()
+
+        XCTAssertEqual("native", result)
+    }
+}