title: TCP communication between Swift iOS and Java Sockets
body: <p>I'm trying to establish a communication between my Java application and the relative (work in progress) iOS application.
  After sockets are opened, the iOS application (client) write an "handshake" string into stream and then it wait on read stream (I think).
  Contemporary the Java application (server, started before the iOS application) open with success the socket and wait on BufferedReader for read the "handshake" and at this point both applications are blocked.
  I don't understand how it is possible?</p>
  
  <p>Follow the part of iOS code:</p>
  
  <pre><code>public class Client: NSObject, NSStreamDelegate  {
  
  var serverAddress: CFString
  let serverPort: UInt32 = 50000
  
  private var inputStream: NSInputStream!
  private var outputStream: NSOutputStream!
  private var connecting:Bool
  
  init(ip:String) {
      serverAddress = ip
      connecting = false
  
      super.init()
  
      connect()
  }
  
  func connect() {
      connecting = true
  
      while connecting {
          print("connecting...")
  
          var readStream:  Unmanaged&lt;CFReadStream&gt;?
          var writeStream: Unmanaged&lt;CFWriteStream&gt;?
  
          CFStreamCreatePairWithSocketToHost(nil, self.serverAddress, self.serverPort, &amp;readStream, &amp;writeStream)
  
          // Documentation suggests readStream and writeStream can be assumed to
          // be non-nil. If you believe otherwise, you can test if either is nil
          // and implement whatever error-handling you wish.
  
          self.inputStream = readStream!.takeRetainedValue()
          self.outputStream = writeStream!.takeRetainedValue()
  
          self.inputStream.delegate = self
          self.outputStream.delegate = self
  
          self.inputStream.scheduleInRunLoop(NSRunLoop.currentRunLoop(), forMode: NSDefaultRunLoopMode)
          self.outputStream.scheduleInRunLoop(NSRunLoop.currentRunLoop(), forMode: NSDefaultRunLoopMode)
  
          self.inputStream.open()
          self.outputStream.open()
  
          // send handshake
  
          let handshake: NSData = "handshake".dataUsingEncoding(NSUTF8StringEncoding)!
          let returnVal = self.outputStream.write(UnsafePointer&lt;UInt8&gt;(handshake.bytes), maxLength: handshake.length)
          print("written: \(returnVal)")
  
  
          // wait to receive handshake
  
          let bufferSize = 1024
          var buffer = Array&lt;UInt8&gt;(count: bufferSize, repeatedValue: 0)
  
          print("waintig for handshake...")
  
          let bytesRead = inputStream.read(&amp;buffer, maxLength: bufferSize)
          if bytesRead &gt;= 0 {
              var output = NSString(bytes: &amp;buffer, length: bytesRead, encoding: NSUTF8StringEncoding)
              print("received from host \(serverAddress): \(output)")
          } else {
              // Handle error
          }
  
          connecting = false
  
          self.inputStream.close()
          self.outputStream.close()
      }
  
  
  }
  
  public func stream(stream: NSStream, handleEvent eventCode: NSStreamEvent) {
      print("stream event")
  
      if stream === inputStream {
          switch eventCode {
          case NSStreamEvent.ErrorOccurred:
              print("input: ErrorOccurred: \(stream.streamError?.description)")
          case NSStreamEvent.OpenCompleted:
              print("input: OpenCompleted")
          case NSStreamEvent.HasBytesAvailable:
              print("input: HasBytesAvailable")
  
              // Here you can `read()` from `inputStream`
  
          default:
              break
          }
      }
      else if stream === outputStream {
          switch eventCode {
          case NSStreamEvent.ErrorOccurred:
              print("output: ErrorOccurred: \(stream.streamError?.description)")
          case NSStreamEvent.OpenCompleted:
              print("output: OpenCompleted")
          case NSStreamEvent.HasSpaceAvailable:
              print("output: HasSpaceAvailable")
  
              // Here you can write() to `outputStream`
              break
  
          default:
              break
          }
      }
  
  }
  </code></pre>
  
  <p>}</p>
  
  <p>Follow the part of Java code (it work perfectly between other computers using the same Java application):</p>
  
  <pre><code>public void run()
  {
      System.out.println("Server.java: waiting for connection");
  
      //accept
      try
      {
          serverSocket = new ServerSocket(portNumber);
          clientSocket = serverSocket.accept();
          reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
          writer = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
  
          System.out.println("Server.java: connected to " + clientSocket.getInetAddress());
  
          // check for input request type
          String line = reader.readLine();    // &lt;----BLOCKED HERE!
  
          if(line.equals("handshake"))
          {
              connected = true;
  
              // send acceptation
              System.out.println("Server.java: Sending handshake, waiting response");
              writer.write("handshake");
              writer.newLine();
              writer.flush();
  
              // .... and the rest of code...
  </code></pre>
  
  <p>When I close the iOS application the Java application unlock from the read, print correctly the received handshake and then continue his job.
  Someone can help me please? </p>