@cappitolian/network-discovery 0.0.13 → 0.0.14

package/ios/Sources/NetworkDiscoveryPlugin/NetworkDiscovery.swift

@@ -4,55 +4,168 @@ import Network
 @objc public class NetworkDiscovery: NSObject {
     private var listener: NWListener?
     private var browser: NWBrowser?
+    private var activeConnections: [NWConnection] = []
 
     @objc public func startPublishing(name: String, type: String, port: Int, metadata: [String: String]) throws {
+        stopServer()
         let nwPort = NWEndpoint.Port(integerLiteral: UInt16(port))
-        // Limpieza de tipo para Bonjour: _ssspos._tcp
         let cleanType = type.contains("_") ? type : "_\(type)._tcp"
         
-        let service = NWListener.Service(name: name, type: cleanType)
-        var txt = TXTRecord()
-        for (key, value) in metadata { txt[key] = value }
-        service.txtRecord = txt
+        let ipForName = metadata["ip"] ?? ""
+        let displayName = ipForName.isEmpty ? name : "\(name)-\(ipForName)"
         
-        listener = try NWListener(using: .tcp, on: nwPort)
+        let mappedMetadata = metadata.mapValues { $0.data(using: .utf8)! }
+        let txtData = NetService.data(fromTXTRecord: mappedMetadata)
+        
+        // --- CONFIGURACIÓN MEJORADA PARA COMPATIBILIDAD CROSS-PLATFORM ---
+        let params = NWParameters.tcp
+        params.includePeerToPeer = true
+        params.allowLocalEndpointReuse = true // Permite reutilización del puerto
+        params.acceptLocalOnly = false // Acepta conexiones de toda la red local
+        
+        // Configuración adicional para que Android pueda resolver
+        if let tcpOptions = params.defaultProtocolStack.internetProtocol as? NWProtocolIP.Options {
+            tcpOptions.version = .any // IPv4 e IPv6
+        }
+        
+        let service = NWListener.Service(name: displayName, type: cleanType, domain: nil, txtRecord: txtData)
+        
+        listener = try NWListener(using: params, on: nwPort)
         listener?.service = service
+        
+        // --- HANDLER CRÍTICO: Aceptar conexiones entrantes ---
+        listener?.newConnectionHandler = { [weak self] connection in
+            print("NSD_LOG: iOS recibió conexión de: \(connection.endpoint)")
+            
+            // Iniciar la conexión para que Android pueda resolver el servicio
+            connection.start(queue: .main)
+            self?.activeConnections.append(connection)
+            
+            // Configurar handlers básicos
+            connection.stateUpdateHandler = { state in
+                if case .ready = state {
+                    print("NSD_LOG: Conexión establecida con Android")
+                }
+            }
+            
+            // Limpieza automática cuando la conexión termine
+            connection.receiveMessage { _, _, _, error in
+                if error != nil {
+                    connection.cancel()
+                    self?.activeConnections.removeAll { $0 === connection }
+                }
+            }
+        }
+        
+        listener?.stateUpdateHandler = { state in
+            switch state {
+            case .ready:
+                if let port = self.listener?.port {
+                    print("NSD_LOG: ✅ iOS Servidor LISTO en puerto \(port): \(displayName)")
+                }
+            case .failed(let error):
+                print("NSD_LOG: ❌ iOS Servidor falló: \(error)")
+            case .waiting(let error):
+                print("NSD_LOG: ⏳ iOS Servidor esperando: \(error)")
+            default:
+                break
+            }
+        }
+        
         listener?.start(queue: .main)
+        
+        // Pequeño delay para asegurar que el servicio esté completamente publicado
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            print("NSD_LOG: Servicio iOS completamente inicializado")
+        }
     }
 
     @objc public func findService(name: String, type: String, timeout: TimeInterval, completion: @escaping ([String: Any]?) -> Void) {
+        stopDiscovery()
         let cleanType = type.contains("_") ? type : "_\(type)._tcp"
-        let parameters = NWParameters()
-        parameters.includePeerToPeer = true
         
-        browser = NWBrowser(for: .bonjour(type: cleanType, domain: nil), using: parameters)
+        // Configuración mejorada para el browser
+        let params = NWParameters()
+        params.includePeerToPeer = true
         
-        browser?.browseResultsChangedHandler = { results, changes in
+        let browser = NWBrowser(for: .bonjour(type: cleanType, domain: nil), using: params)
+        self.browser = browser
+        var finished = false
+
+        browser.browseResultsChangedHandler = { [weak self] results, _ in
             for result in results {
-                if case let .service(foundName, _, _, _) = result.endpoint, foundName == name {
-                    // En iOS, el resolve de IP requiere un paso adicional de conexión 
-                    // o extraerlo del TXTRecord si lo envías ahí.
-                    self.stopBrowsing()
-                    completion(["ip": "vía-mDNS", "port": 0]) // Placeholder lógico
+                if case let .service(foundName, _, _, _) = result.endpoint, foundName.contains(name) {
+                    if !finished {
+                        finished = true
+                        
+                        print("NSD_LOG: iOS Cliente encontró servicio: \(foundName)")
+                        
+                        var meta: [String: String] = [:]
+                        if case let .bonjour(txt) = result.metadata {
+                            for (k, v) in txt.dictionary {
+                                if let dataValue = v as? Data {
+                                    meta[k] = String(data: dataValue, encoding: .utf8) ?? ""
+                                }
+                            }
+                        }
+                        
+                        // --- LÓGICA DE EXTRACCIÓN ROBUSTA ---
+                        var ip = meta["ip"] ?? ""
+                        
+                        if (ip.isEmpty || ip == "0.0.0.0") && foundName.contains("-") {
+                            ip = foundName.components(separatedBy: "-").last ?? ""
+                        }
+                        
+                        if ip.isEmpty || ip == "0.0.0.0" {
+                            if case let .hostPort(host, _) = result.endpoint {
+                                ip = "\(host)".components(separatedBy: "%").first ?? "\(host)"
+                            }
+                        }
+
+                        print("NSD_LOG: IP extraída: \(ip)")
+                        
+                        self?.stopDiscovery()
+                        completion(["ip": ip, "port": 8081, "metadata": meta])
+                    }
                     return
                 }
             }
         }
         
-        browser?.start(queue: .main)
-        DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
-            self.stopBrowsing()
-            completion(nil)
+        browser.stateUpdateHandler = { state in
+            switch state {
+            case .ready:
+                print("NSD_LOG: iOS Browser listo para buscar")
+            case .failed(let error):
+                print("NSD_LOG: iOS Browser falló: \(error)")
+            default:
+                break
+            }
+        }
+        
+        browser.start(queue: .main)
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout) { [weak self] in
+            if !finished {
+                finished = true
+                print("NSD_LOG: iOS Búsqueda timeout")
+                self?.stopDiscovery()
+                completion(nil)
+            }
         }
     }
 
-    private func stopBrowsing() {
-        browser?.cancel()
-        browser = nil
-    }
-
-    @objc public func stopPublishing() {
+    @objc public func stopServer() {
+        // Limpiar todas las conexiones activas
+        activeConnections.forEach { $0.cancel() }
+        activeConnections.removeAll()
+        
         listener?.cancel()
         listener = nil
+        print("NSD_LOG: iOS Servidor detenido")
+    }
+    
+    @objc public func stopDiscovery() {
+        browser?.cancel()
+        browser = nil
     }
 }

package/ios/Sources/NetworkDiscoveryPlugin/NetworkDiscoveryPlugin.swift

@@ -1,16 +1,10 @@
 import Foundation
 import Capacitor
 
-/**
- * Registro moderno de Capacitor para Swift.
- * 'NetworkDiscovery' es el nombre que usas en registerPlugin en TS.
- */
 @objc(NetworkDiscoveryPlugin)
 public class NetworkDiscoveryPlugin: CAPPlugin, CAPBridgedPlugin {
-    public let identifier = "NetworkDiscoveryPlugin" 
-    public let jsName = "NetworkDiscovery" 
-    
-    // Mapeo de métodos para el Bridge
+    public let identifier = "NetworkDiscoveryPlugin"
+    public let jsName = "NetworkDiscovery"
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "startServer", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "stopServer", returnType: CAPPluginReturnPromise),
@@ -22,44 +16,28 @@ public class NetworkDiscoveryPlugin: CAPPlugin, CAPBridgedPlugin {
     @objc func startServer(_ call: CAPPluginCall) {
         guard let name = call.getString("serviceName"),
               let type = call.getString("serviceType"),
-              let port = call.getInt("port") else {
-            call.reject("Faltan parámetros obligatorios")
-            return
-        }
+              let port = call.getInt("port") else { return call.reject("Faltan parámetros") }
         
         let metadata = call.getObject("metadata") as? [String: String] ?? [:]
-
         do {
             try implementation.startPublishing(name: name, type: type, port: port, metadata: metadata)
             call.resolve()
-        } catch {
-            call.reject("Error iniciando servidor mDNS: \(error.localizedDescription)")
-        }
+        } catch { call.reject(error.localizedDescription) }
     }
 
     @objc func stopServer(_ call: CAPPluginCall) {
-        implementation.stopPublishing()
+        implementation.stopServer()
         call.resolve()
     }
 
     @objc func findServer(_ call: CAPPluginCall) {
         guard let name = call.getString("serviceName"),
-              let type = call.getString("serviceType") else {
-            call.reject("Nombre o tipo de servicio no proporcionado")
-            return
-        }
-        let timeout = Double(call.getInt("timeout") ?? 5000) / 1000.0
-
+              let type = call.getString("serviceType") else { return call.reject("Faltan parámetros") }
+        
+        let timeout = Double(call.getInt("timeout") ?? 10000) / 1000.0
         implementation.findService(name: name, type: type, timeout: timeout) { result in
-            if let result = result {
-                call.resolve([
-                    "ip": result.ip,
-                    "port": result.port,
-                    "metadata": result.metadata
-                ])
-            } else {
-                call.reject("No se encontró el servidor tras \(timeout) segundos")
-            }
+            if let data = result { call.resolve(data) } 
+            else { call.reject("TIMEOUT_ERROR") }
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cappitolian/network-discovery",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "A Capacitor plugin for network service discovery using mDNS/Bonjour. Allows automatic server-client connection without manual IP configuration.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",