Running async tcp connection on swiftUi chat app - asynchronous

Question

For a school project, I have to create a swiftUi chat app.
I'm fairly new to swift but managed to use the Network framework to connect to my chat server using the following code :
import Foundation
import Network
class Client {
let connection: Connection
let host: NWEndpoint.Host
let port: NWEndpoint.Port
var queue: DispatchQueue = DispatchQueue.init(label: "keepAlive")
init(host: String, port: UInt16) {
self.host = NWEndpoint.Host(host)
self.port = NWEndpoint.Port(rawValue: port)!
let nwConnection = NWConnection(host: self.host, port: self.port, using: .tcp)
connection = BaburuConnection(nwConnection: nwConnection)
}
func start() {
print("Client started \(host) \(port)")
connection.didStopCallback = didStopCallback(error:)
connection.start()
}
func stop() {
connection.stop()
}
func sendMessage(content: String, channel: UUID) {
let msg = Data(Frame.Message(value: content, channel: channel).serialize())
connection.send(data: msg)
}
func sendCommand(command: CommandKind, args: [String]? = nil) {
let cmd = Data(Frame.Cmd(cmd: Command(kind: command, args: args)).serialize())
connection.send(data: cmd)
}
func isConnected() -> Bool {
return connection.running
}
func didStopCallback(error: Error?) {
if error == nil {
exit(EXIT_SUCCESS)
} else {
exit(EXIT_FAILURE)
}
}
}
import Foundation
import Network
var KeepAlive = 30
var maxReadLength = 4096
class Connection {
let nwConnection: NWConnection
let queue = DispatchQueue(label: "Client connection Q")
var running = false
private var serializedKA = Frame.KeepAlive().serialize()
private lazy var timer = Timer(timeInterval: TimeInterval(KeepAlive), repeats: true) { _ in
self.send(data: Data(Frame.KeepAlive().serialize()))
}
init(nwConnection: NWConnection) {
self.nwConnection = nwConnection
}
var didStopCallback: ((Error?) -> Void)? = nil
func start() {
print("connection will start")
nwConnection.stateUpdateHandler = stateDidChange(to:)
setupReceive()
nwConnection.start(queue: queue)
running = true
DispatchQueue.global(qos: .background).async {
let runLoop = RunLoop.current
runLoop.add(self.timer, forMode: .default)
runLoop.run()
}
}
private func stateDidChange(to state: NWConnection.State) {
switch state {
case .waiting(let error):
connectionDidFail(error: error)
case .ready:
print("Client connection ready")
case .failed(let error):
connectionDidFail(error: error)
default:
break
}
}
private func setupReceive() {
nwConnection.receive(minimumIncompleteLength: 1, maximumLength: maxReadLength) { (data, _, isComplete, error) in
if let data = data, !data.isEmpty {
let message = String(data: data, encoding: .utf8)
print("connection did receive, data: \(data as NSData) string: \(message ?? "-" )")
switch(Frame.parse(reader: BufferedString(str: message!))) {
case .success(let res):
if res is Frame.MessageWrapper {
print("message : ", res)
} else if res is Frame.Cmd {
print("command : ", res)
} else {
print("TODO")
}
case .failure(let err):
print(err)
}
}
if isComplete {
self.connectionDidEnd()
} else if let error = error {
self.connectionDidFail(error: error)
} else {
self.setupReceive()
}
}
}
func send(data: Data) {
nwConnection.send(content: data, completion: .contentProcessed( { error in
if let error = error {
self.connectionDidFail(error: error)
return
}
print("connection did send, data: \(data as NSData)")
}))
}
func stop() {
print("connection will stop")
self.timer.invalidate()
running = false
stop(error: nil)
}
private func connectionDidFail(error: Error) {
print("connection did fail, error: \(error)")
self.stop(error: error)
}
private func connectionDidEnd() {
print("connection did end")
self.stop(error: nil)
}
private func stop(error: Error?) {
self.nwConnection.stateUpdateHandler = nil
self.nwConnection.cancel()
if let didStopCallback = self.didStopCallback {
self.didStopCallback = nil
didStopCallback(error)
}
}
}
The code works fine when I use it with a blocking operation beneath it but I can't think of any good solution for implementing it in mw swiftUi app since I need to keep some sort of reference on the Client object in order to call it's sendMessage and sendCommand methods with a button and notify my ui when I receive a message.
Does anyone has any advises ?
Also, if there is a cleaner way than recursion for async reading, I would gladly change it.