Swift: Recevoir UDP avec GCDAsyncUdpSocket

De FOND:

Je veux être en mesure d'envoyer et de recevoir des paquets UDP entre mon application iOS et un serveur.
Le serveur renvoie l'écho de chaque message entrant pour le client de l'application. Le serveur est testé et confirmé travailler. J'ai un StartViewController qui le démarrage de deux classes qui implémente GCDAsyncUdpSocketDelegate, l'un pour l'envoi et l'autre pour la réception. L'envoi "socket" est au travail, le serveur reçoit les messages.

PROBLÈME:

L'application ne jamais obtenir le message entrant de retour après avoir été envoyé. Quelque chose avec le socket d'écoute de l'installation est probablement mal car didReceiveData jamais appelée.

Ai-je fait cela complètement faux?

Début:

class StartViewController: UIViewController {

   var inSocket : InSocket!
   var outSocket : OutSocket!

   override func viewDidLoad() {
       super.viewDidLoad()
       inSocket = InSocket()
       outSocket = OutSocket()
   }

   @IBAction func goButton(sender: UIButton) {
       outSocket.send("This is a message!")
   }
}

Recevoir:

class InSocket: NSObject, GCDAsyncUdpSocketDelegate {

   let IP = "255.255.255.255"
   let PORT:UInt16 = 5556
   var socket:GCDAsyncUdpSocket!

   override init(){
       super.init()
       setupConnection()
   }

   func setupConnection(){
       var error : NSError?
       socket = GCDAsyncUdpSocket(delegate: self, delegateQueue: dispatch_get_main_queue())
       socket.bindToPort(PORT, error: &error)
       socket.enableBroadcast(true, error: &error)
       socket.joinMulticastGroup(IP, error: &error)
       socket.beginReceiving(&error)
   }

   func udpSocket(sock: GCDAsyncUdpSocket!, didReceiveData data: NSData!, fromAddress address: NSData!,      withFilterContext filterContext: AnyObject!) {
       println("incoming message: \(data)");
   }
}

Envoyer:

class OutSocket: NSObject, GCDAsyncUdpSocketDelegate {

   let IP = "90.112.76.180"
   let PORT:UInt16 = 5556
   var socket:GCDAsyncUdpSocket!

   override init(){
       super.init()
       setupConnection()
   }

   func setupConnection(){
       var error : NSError?
       socket = GCDAsyncUdpSocket(delegate: self, delegateQueue: dispatch_get_main_queue())
       socket.connectToHost(IP, onPort: PORT, error: &error)
   }

   func send(message:String){
       let data = message.dataUsingEncoding(NSUTF8StringEncoding)
       socket.sendData(data, withTimeout: 2, tag: 0)
   }

   func udpSocket(sock: GCDAsyncUdpSocket!, didConnectToAddress address: NSData!) {
       println("didConnectToAddress");
   }

   func udpSocket(sock: GCDAsyncUdpSocket!, didNotConnect error: NSError!) {
       println("didNotConnect \(error)")
   }

   func udpSocket(sock: GCDAsyncUdpSocket!, didSendDataWithTag tag: Int) {
       println("didSendDataWithTag")
   } 

   func udpSocket(sock: GCDAsyncUdpSocket!, didNotSendDataWithTag tag: Int, dueToError error: NSError!) {
        println("didNotSendDataWithTag")
   }
}

Edit:
Ajouté oublié la ligne de code.

Exactement où avez-vous initialiser votre prise de propriété dans InSocket. setupConnection?
Anton. Thx pour s'en rendre compte. C'était un copier/coller misstake de mon projet de code, j'ai juste ajouté. Ce n'est pas le problème, toutefois, car le socket initialazion est là, dans mon projet de code.

OriginalL'auteur rilar | 2014-11-06

11

J'ai enfin réussi à le faire fonctionner avec cette prise d'installation:
```
func setupConnection(){
    var error : NSError?
    socket = GCDAsyncUdpSocket(delegate: self, delegateQueue: dispatch_get_main_queue())
    socket.bindToPort(PORT, error: &error)
    socket.connectToHost(SERVER_IP, onPort: PORT, error: &error)
    socket.beginReceiving(&error)
    send("ping")
}

func send(message:String){
   let data = message.dataUsingEncoding(NSUTF8StringEncoding)
   socket.sendData(data, withTimeout: 2, tag: 0)
}
```
thx cela a été d'une grande aide pour moi!
Désolé de ré-ouvrir un vieux thread, mais je suis en train de convertir votre exemple de fonction avec Swift 2.1, et je suis un peu confus quant à ce que le SERVER_IP vous faites référence dans votre réponse vraiment se réfère. Je n'arrive pas à trouver qui a instancié n'importe où.
Désolé de ne pas être plus clair à ce sujet, SERVER_IP est une chaîne de caractères.
Merci @rilar. J'avais fait l'amour pour voir plus de la version révisée du code, si jamais vous êtes prêt à partager. Je n'étais pas clair si le setupConnection() de cette réponse faisait partie de la InSocket ou OutSocket de la classe, ou exactement où SERVER_IP est instanciée.
J'ai cherché longtemps une solution pour envoyer des données UDP. Cela m'a aidé, Merci!. Maintenant, je veux savoir comment je peux lire la Réponse du Serveur. Il n'y a que outSocket.réponse() la méthode mais je ne sais pas comment l'utiliser! Quelqu'un peut m'aider. J'ai vu le serveur est de répondre via WireShark mais ne pas le recevoir dans ma demande.

OriginalL'auteur rilar

Apple Swift version 4.2.1 Bien Testé UDP Exemple:-

ÉTAPE 1 :- pod 'CocoaAsyncSocket'

ÉTAPE 2 :- import CocoaAsyncSocket dans votre UIViewController.

ÉTAPE 3 :- UIViewController

        import UIKit
import CocoaAsyncSocket

class ViewController: UIViewController {
    @IBOutlet weak var btnOnOff: LightButton!
    @IBOutlet weak var lblStatus: UILabel!
    var inSocket : InSocket!
    var outSocket : OutSocket!
    override func viewDidLoad() {
        super.viewDidLoad()
        lblStatus.isHidden = true
        inSocket = InSocket()
        outSocket = OutSocket()
        outSocket.setupConnection {
            self.lblStatus.isHidden = false
        }
    }
    @IBAction func btnLight(_ sender: Any) {
        let signal:Signal = Signal()
        self.outSocket.send(signal: signal)
    }
}

ÉTAPE 4 :- Reciving Socket

       //Reciving End...
class InSocket: NSObject, GCDAsyncUdpSocketDelegate {
   //let IP = "10.123.45.2"
    let IP = "127.0.0.1"
    let PORT:UInt16 = 5001
    var socket:GCDAsyncUdpSocket!
    override init(){
        super.init()
        setupConnection()
    }
    func setupConnection(){
        socket = GCDAsyncUdpSocket(delegate: self, delegateQueue:DispatchQueue.main)
        do { try socket.bind(toPort: PORT)} catch { print("")}
        do { try socket.enableBroadcast(true)} catch { print("not able to brad cast")}
        do { try socket.joinMulticastGroup(IP)} catch { print("joinMulticastGroup not procceed")}
        do { try socket.beginReceiving()} catch { print("beginReceiving not procceed")}
    }
    //MARK:-GCDAsyncUdpSocketDelegate
    func udpSocket(_ sock: GCDAsyncUdpSocket, didReceive data: Data, fromAddress address: Data, withFilterContext filterContext: Any?) {
          print("incoming message: \(data)");
          let signal:Signal = Signal.unarchive(d: data)
          print("signal information : \n first \(signal.firstSignal) , second \(signal.secondSignal) \n third \(signal.thirdSignal) , fourth \(signal.fourthSignal)")

    }
    func udpSocket(_ sock: GCDAsyncUdpSocket, didNotConnect error: Error?) {
    }

    func udpSocketDidClose(_ sock: GCDAsyncUdpSocket, withError error: Error?) {
    }
}

ÉTAPE 5 :- l'Envoi de Socket..

//Sending End...
class OutSocket: NSObject, GCDAsyncUdpSocketDelegate {
//let IP = "10.123.45.1"
    let IP = "127.0.0.1"
let PORT:UInt16 = 5001
var socket:GCDAsyncUdpSocket!
override init(){
super.init()
}
func setupConnection(success:(()->())){
socket = GCDAsyncUdpSocket(delegate: self, delegateQueue:DispatchQueue.main)
do { try socket.bind(toPort: PORT)} catch { print("")}
do { try socket.connect(toHost:IP, onPort: PORT)} catch { print("joinMulticastGroup not procceed")}
do { try socket.beginReceiving()} catch { print("beginReceiving not procceed")}
success()
}
func send(signal:Signal){
let signalData = Signal.archive(w: signal)
socket.send(signalData, withTimeout: 2, tag: 0)
}
//MARK:- GCDAsyncUdpSocketDelegate
    func udpSocket(_ sock: GCDAsyncUdpSocket, didConnectToAddress address: Data) {
print("didConnectToAddress");
}
func udpSocket(_ sock: GCDAsyncUdpSocket, didNotConnect error: Error?) {
if let _error = error {
print("didNotConnect \(_error )")
}
}
func udpSocket(_ sock: GCDAsyncUdpSocket, didNotSendDataWithTag tag: Int, dueToError error: Error?) {
print("didNotSendDataWithTag")
}
func udpSocket(_ sock: GCDAsyncUdpSocket, didSendDataWithTag tag: Int) {
print("didSendDataWithTag")
}
}

ÉTAPE 6 :- Votre Signal Données qui vous Envoyer/Recevoir

import Foundation
struct Signal {
var firstSignal:UInt16 = 20
var secondSignal:UInt16 = 30
var thirdSignal: UInt16  = 40
var fourthSignal: UInt16 = 50
static func archive(w:Signal) -> Data {
var fw = w
return Data(bytes: &fw, count: MemoryLayout<Signal>.stride)
}
static func unarchive(d:Data) -> Signal {
guard d.count == MemoryLayout<Signal>.stride else {
fatalError("BOOM!")
}
var s:Signal?
d.withUnsafeBytes({(bytes: UnsafePointer<Signal>)->Void in
s = UnsafePointer<Signal>(bytes).pointee
})
return s!
}
}

OriginalL'auteur Abhimanyu Rathore

Vous devez vous connecter pour publier un commentaire.