To demonstrate, I have written a server that has one task. It reads a word and sends it back to the client in a reversed form.
The server code in few lines ;/
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
# Make sure to "gem install eventmachine" require 'eventmachine' # Define the receive_data in it's own module. # The module will be injected when the server is started. # receive_data will read the sent data from the client and send it back # reversed to the same client. module ReverseServer def receive_data data send_data data.reverse # To close the client connection after writing, call; # close_connection_after_writing() end end # When the server's process is being killed, shutdown the server... ['TERM', 'INT'].each do |signal| trap(signal) do EventMachine::stop() end end # Start the server on the port 2299... EventMachine::run { puts 'Starting the server...' EventMachine::start_server "127.0.0.1", 2299, ReverseServer } |
The client, which is written as a part of an IOS application in Swift;
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
import Foundation class ReverseClient: NSObject, NSStreamDelegate { // The server host to connect to. private var host:String? // Server's port private var port:Int? // Socket stream to read from private var inputStream: NSInputStream? // Socket stream to write to private var outputStream: NSOutputStream? // Lets declare a callback func to spit out when new data is read. // This func is assigned each time a data is written to the server. Se (reverseWord func) private var dataReadCallback:((dataReceived:String)->Void)? // To connect to the server func connect(host: String, port: Int) { self.host = host self.port = port NSStream.getStreamsToHostWithName(host, port: port, inputStream: &self.inputStream, outputStream: &self.outputStream) if self.inputStream != nil && self.outputStream != nil { self.inputStream!.delegate = self self.outputStream!.delegate = self self.inputStream!.scheduleInRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) self.outputStream!.scheduleInRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) self.inputStream!.open() self.outputStream!.open() } } // This is a call back func that takes care of I/O from/to the server. // Read about this func. There are many event codes to handle. // I just wanted to make it simple. func stream(aStream: NSStream, handleEvent eventCode: NSStreamEvent) { if aStream != inputStream { return } if eventCode == .HasBytesAvailable { self.read() } } // When it's time to read from the server. // It is called internally in the stream delegate function (se above). private func read() -> String { var buffer = [UInt8](count: 1024, repeatedValue: 0) var output: String = "" while (self.inputStream!.hasBytesAvailable){ let bytesRead: Int = inputStream!.read(&buffer, maxLength: buffer.count) if bytesRead >= 0 { output += NSString(bytes: UnsafePointer(buffer), length: bytesRead, encoding: NSUTF8StringEncoding)! as String } } self.dataReadCallback!(dataReceived: output) return output } // When writing to the server... // The first argument is the word to reverse. // The second argument is a function callback. The argument (dataReceived) is assigned // when the reversed word is received. func reverseWord(word:String) -> Int{ if self.outputStream == nil { NSException(name: "Not connected to the server", reason: "Make sure to connect first", userInfo: nil).raise() } let data:NSData = word.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)! let bytesWritten:Int = self.outputStream!.write(UnsafePointer(data.bytes), maxLength: data.length) return bytesWritten } // When data is received from the server. func onDataReceived(dataReadCallback:((dataReceived:String) -> Void)) { self.dataReadCallback = dataReadCallback } // When it is time to close the connection to the server. func close() -> Bool { if ( self.inputStream == nil) || (self.outputStream == nil) {return false } self.inputStream?.removeFromRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) self.outputStream?.removeFromRunLoop(.mainRunLoop(), forMode: NSDefaultRunLoopMode) inputStream?.close() outputStream?.close() inputStream = nil outputStream = nil return true } } |
The demo application that I wrote is a single view-based IOS-application, with 1 textfield, label and button.
An instance of ReverseClient is created in the ViewController…
|
1 2 3 4 5 |
class ViewController: UIViewController { let reverseClient:ReverseClient = ReverseClient() ... |
And when the button is pressed;
|
1 2 3 4 5 6 7 8 9 10 11 |
@IBAction func btnClicked(sender: UIButton) { reverseClient.connect("127.0.0.1", port: 2299) reverseClient.reverseWord(self.textField.text!) reverseClient.onDataReceived { (dataReceived) -> Void in self.resultLabel.text = dataReceived self.reverseClient.close() } } |
Do not forget to start the server!
