Bondruck aus SwiftUI App

Chris schrieb:

Bevor du dich mit NSConnection rumschlägst und graue Haare bekommst…

Quellcode

1. class Connection: NSObject, GCDAsyncSocketDelegate {
3. private var asyncSocket: GCDAsyncSocket? = nil
4. private let delegateQueue = DispatchQueue(label: "delegateQueue")
5. private let timeout: TimeInterval = 40.0
7. init() {
8. super.init()
9. }
11. func connect (ipAdress: String, port: Int16) {
12. self.asyncSocket = GCDAsyncSocket.init(delegate: self, delegateQueue: self.delegateQueue)
13. self.asyncSocket?.isIPv6Enabled = false
14. do
15. {
16. try self.asyncSocket?.connect(toHost: ipAdress, onPort: UInt16(port), withTimeout: 30)
17. }
18. catch {
19. LogInfo("error: \(error)")
20. }
21. }
23. func disconnect() {
24. self.asyncSocket?.disconnect()
25. self.asyncSocket = nil
26. }
28. func writeData(data: Data, tag: Int = 10) {
29. self.asyncSocket?.write(data, withTimeout: timeout, tag: tag)
30. LogInfo("Write")
31. }
33. // MARK: - GCDAsyncSocketDelegate
34. /**
35. * Called when a socket connects and is ready for reading and writing.
36. * The host parameter will be an IP address, not a DNS name.
37. **/
39. func socket(_ sock: GCDAsyncSocket, didConnectToHost host: String, port: UInt16) {
40. print("connected to host: \(host)")
41. self.asyncSocket?.readData(withTimeout: timeout, tag: 1)
42. }
44. /**
45. * Called when a socket has completed reading the requested data into memory.
46. * Not called if there is an error.
47. **/
48. func socket(_ sock: GCDAsyncSocket, didRead data: Data, withTag tag: Int) {
50. LogInfo("Read")
51. logHexDumpForBytes(bytes: Array<UInt8>(data))
52. self.asyncSocket?.readData(withTimeout: timeout, tag: 1)
53. }
55. /**
56. * Called when a socket has completed writing the requested data. Not called if there is an error.
57. **/
58. func socket(_ sock: GCDAsyncSocket, didWriteDataWithTag tag: Int) {
59. }
61. /**
62. * Called if a read operation has reached its timeout without completing.
63. * This method allows you to optionally extend the timeout.
64. * If you return a positive time interval (> 0) the read's timeout will be extended by the given amount.
65. * If you don't implement this method, or return a non-positive time interval (<= 0) the read will timeout as usual.
66. *
67. * The elapsed parameter is the sum of the original timeout, plus any additions previously added via this method.
68. * The length parameter is the number of bytes that have been read so far for the read operation.
69. *
70. * Note that this method may be called multiple times for a single read if you return positive numbers.
71. **/
72. func socket(_ sock: GCDAsyncSocket, shouldTimeoutReadWithTag tag: Int, elapsed: TimeInterval, bytesDone length: UInt) -> TimeInterval {
73. print("Read timeout")
74. return timeout
75. }
77. /**
78. * Called if a write operation has reached its timeout without completing.
79. * This method allows you to optionally extend the timeout.
80. * If you return a positive time interval (> 0) the write's timeout will be extended by the given amount.
81. * If you don't implement this method, or return a non-positive time interval (<= 0) the write will timeout as usual.
82. *
83. * The elapsed parameter is the sum of the original timeout, plus any additions previously added via this method.
84. * The length parameter is the number of bytes that have been written so far for the write operation.
85. *
86. * Note that this method may be called multiple times for a single write if you return positive numbers.
87. **/
88. func socket(_ sock: GCDAsyncSocket, shouldTimeoutWriteWithTag tag: Int, elapsed: TimeInterval, bytesDone length: UInt) -> TimeInterval {
89. print("Write timeout")
90. return timeout
91. }
93. /**
94. * Called when a socket disconnects with or without error.
95. *
96. * If you call the disconnect method, and the socket wasn't already disconnected,
97. * then an invocation of this delegate method will be enqueued on the delegateQueue
98. * before the disconnect method returns.
99. *
100. * Note: If the GCDAsyncSocket instance is deallocated while it is still connected,
101. * and the delegate is not also deallocated, then this method will be invoked,
102. * but the sock parameter will be nil. (It must necessarily be nil since it is no longer available.)
103. * This is a generally rare, but is possible if one writes code like this:
104. *
105. * asyncSocket = nil; // I'm implicitly disconnecting the socket
106. *
107. * In this case it may preferrable to nil the delegate beforehand, like this:
108. *
109. * asyncSocket.delegate = nil; // Don't invoke my delegate method
110. * asyncSocket = nil; // I'm implicitly disconnecting the socket
111. *
112. * Of course, this depends on how your state machine is configured.
113. **/
114. func socketDidDisconnect(_ sock: GCDAsyncSocket, withError err: Error?) {
115. LogInfo("disconnected: \(String(describing: err))")
116. }
117. }

Alles anzeigen