Scheduling socket communication for Swift

Question

I am fairly new to Swift programming, please forgive the dummy questions I have got to ask below.

In my app, I am trying to schedule to call a function, which will receive some data from my server and will be called every second. The communication needs to be achieved via a TCP socket. After doing some research, it seems to me that I need to have a way to properly use threads to call that function. So here comes my questions:

Where should I make the connection to the server? (Should I make the connection in the viewDidLoad() function of my first view controller?)
Where should I create a thread to schedule the function call? If I create the thread inside my first view controller, would the thread die after I switching to another view controller?
What QoS level I should use for that thread? The app is rendering the data received from the server every second, so I assume this task would have a very high priority.

I tried looking for tutorials and examples about threads and socket communications, but I could not find information that is applicable to my app. So any help or insight regarding the design would be greatly appreciated!

Thanks in advance!

cafemike · Accepted Answer

After some digging, I have found the way to implement stream programming on the Swift side (using native Swift capabilities). It turns out that the way in Swift is very much like the way in Objective C.

The two functions required to enable stream programming in Swift are func connect(), which I had to write by myself, and func stream(_ aStream: Stream, handle eventCode: Stream.Event), which is provided as a method in StreamDelegate.

Here is what func connect() looks like:

func connect() {
    Stream.getStreamsToHost(withName: , port: , inputStream: &inputStream, outputStream: &)

    guard let inputStream = inputStream, let outputStream = outputStream else {
        print(" ->	NetworkControllerError: Cannot open inputstream/outputstream.")
        return
    }

    // Set delegate
    inputStream.delegate = self
    outputStream.delegate = self

    let socketWorkQueue = DispatchQueue(label: "socketWorkQueue", attributes: .concurrent)
    CFReadStreamSetDispatchQueue(inputStream, socketWorkQueue)
    CFWriteStreamSetDispatchQueue(outputStream, socketWorkQueue)

    inputStream.open()
    outputStream.open()
}

And here is what the func stream(_ aStream: Stream, handle eventCode: Stream.Event) looks like:

func stream(_ aStream: Stream, handle eventCode: Stream.Event) {

    if aStream === inputStream {
        switch eventCode {
        case Stream.Event.errorOccurred:
            streamEventQueue.async {
                // do something here
            }
            break
        case Stream.Event.openCompleted:
            streamEventQueue.async {
                // do something here
            }
            break
        case Stream.Event.hasBytesAvailable:
            streamEventQueue.async {
                // do something here
                let output = read()
            }
            break
        case Stream.Event.endEncountered:
            streamEventQueue.async {
                // do something here
            }
            break
        default:
            break
        }
    }
    else if aStream === outputStream {
        switch eventCode {
        case Stream.Event.errorOccurred:
            streamEventQueue.async {
                // do something here
            }
            break
        case Stream.Event.openCompleted:
            streamEventQueue.async {
                // do something here
            }
            break
        default:
            break
        }
    }
}

So the stream() function should be the only place in my app to handle state transitions caused by network connection/disconnection. Note that I also used a serial event queue to process the stream event. This is to prevent any potential race condition which might lead to state corruption.

For those who are not very familiar with stream programming, this is a server-client communication pattern which keeps the connection/socket alive. The connection is required to stay alive mostly due to there is a constant communication between the server and the client. Communication patterns like RESTful API would burden the server significantly by clients' requests and hence not recommended.

Scheduling socket communication for Swift

Answers (2)

Related Questions