only use self when needed
This commit is contained in:
Erik
parent
77ed87d0d4
commit
61b4628d3e
@ -53,11 +53,11 @@ struct SocketAckManager {
|
||||
private var acks = Set<SocketAck>(minimumCapacity: 1)
|
||||
|
||||
mutating func addAck(ack:Int, callback:AckCallback) {
|
||||
self.acks.insert(SocketAck(ack: ack, callback: callback))
|
||||
acks.insert(SocketAck(ack: ack, callback: callback))
|
||||
}
|
||||
|
||||
mutating func executeAck(ack:Int, items:[AnyObject]?) {
|
||||
let callback = self.acks.remove(SocketAck(ack: ack))
|
||||
let callback = acks.remove(SocketAck(ack: ack))
|
||||
|
||||
dispatch_async(dispatch_get_main_queue()) {
|
||||
callback?.callback(items)
|
||||
@ -65,7 +65,7 @@ struct SocketAckManager {
|
||||
}
|
||||
|
||||
mutating func timeoutAck(ack:Int) {
|
||||
let callback = self.acks.remove(SocketAck(ack: ack))
|
||||
let callback = acks.remove(SocketAck(ack: ack))
|
||||
|
||||
dispatch_async(dispatch_get_main_queue()) {
|
||||
callback?.callback(["NO ACK"])
|
||||
|
||||
@ -59,21 +59,21 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
let logType = "SocketEngine"
|
||||
|
||||
var connected:Bool {
|
||||
return self._connected
|
||||
return _connected
|
||||
}
|
||||
weak var client:SocketEngineClient?
|
||||
var cookies:[NSHTTPCookie]?
|
||||
var log = false
|
||||
var pingInterval:Int?
|
||||
var polling:Bool {
|
||||
return self._polling
|
||||
return _polling
|
||||
}
|
||||
var sid = ""
|
||||
var socketPath = ""
|
||||
var urlPolling:String?
|
||||
var urlWebSocket:String?
|
||||
var websocket:Bool {
|
||||
return self._websocket
|
||||
return _websocket
|
||||
}
|
||||
var ws:WebSocket?
|
||||
|
||||
@ -98,16 +98,16 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
public init(client:SocketEngineClient, sessionDelegate:NSURLSessionDelegate?) {
|
||||
self.client = client
|
||||
self.session = NSURLSession(configuration: NSURLSessionConfiguration.ephemeralSessionConfiguration(),
|
||||
delegate: sessionDelegate, delegateQueue: self.workQueue)
|
||||
delegate: sessionDelegate, delegateQueue: workQueue)
|
||||
}
|
||||
|
||||
public convenience init(client:SocketEngineClient, opts:NSDictionary?) {
|
||||
self.init(client: client, sessionDelegate: opts?["sessionDelegate"] as? NSURLSessionDelegate)
|
||||
self.forceWebsockets = opts?["forceWebsockets"] as? Bool ?? false
|
||||
self.forcePolling = opts?["forcePolling"] as? Bool ?? false
|
||||
self.cookies = opts?["cookies"] as? [NSHTTPCookie]
|
||||
self.log = opts?["log"] as? Bool ?? false
|
||||
self.socketPath = opts?["path"] as? String ?? ""
|
||||
forceWebsockets = opts?["forceWebsockets"] as? Bool ?? false
|
||||
forcePolling = opts?["forcePolling"] as? Bool ?? false
|
||||
cookies = opts?["cookies"] as? [NSHTTPCookie]
|
||||
log = opts?["log"] as? Bool ?? false
|
||||
socketPath = opts?["path"] as? String ?? ""
|
||||
}
|
||||
|
||||
deinit {
|
||||
@ -117,21 +117,21 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
public func close(#fast:Bool) {
|
||||
SocketLogger.log("Engine is being closed. Fast: \(fast)", client: self)
|
||||
|
||||
self.pingTimer?.invalidate()
|
||||
self.closed = true
|
||||
pingTimer?.invalidate()
|
||||
closed = true
|
||||
|
||||
self.ws?.disconnect()
|
||||
ws?.disconnect()
|
||||
|
||||
if fast || self.polling {
|
||||
self.write("", withType: PacketType.CLOSE, withData: nil)
|
||||
self.client?.engineDidClose("Disconnect")
|
||||
if fast || polling {
|
||||
write("", withType: PacketType.CLOSE, withData: nil)
|
||||
client?.engineDidClose("Disconnect")
|
||||
}
|
||||
|
||||
self.stopPolling()
|
||||
stopPolling()
|
||||
}
|
||||
|
||||
private func createBinaryDataForSend(data:NSData) -> (NSData?, String?) {
|
||||
if self.websocket {
|
||||
if websocket {
|
||||
var byteArray = [UInt8](count: 1, repeatedValue: 0x0)
|
||||
byteArray[0] = 4
|
||||
var mutData = NSMutableData(bytes: &byteArray, length: 1)
|
||||
@ -148,18 +148,18 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
}
|
||||
|
||||
private func createURLs(params:[String: AnyObject]?) -> (String, String) {
|
||||
if self.client == nil {
|
||||
return ("", "")
|
||||
private func createURLs(params:[String: AnyObject]?) -> (String?, String?) {
|
||||
if client == nil {
|
||||
return (nil, nil)
|
||||
}
|
||||
|
||||
let path = self.socketPath == "" ? "/socket.io" : self.socketPath
|
||||
let path = socketPath == "" ? "/socket.io" : socketPath
|
||||
|
||||
var url = "\(self.client!.socketURL)\(path)/?transport="
|
||||
var url = "\(client!.socketURL)\(path)/?transport="
|
||||
var urlPolling:String
|
||||
var urlWebSocket:String
|
||||
|
||||
if self.client!.secure {
|
||||
if client!.secure {
|
||||
urlPolling = "https://" + url + "polling"
|
||||
urlWebSocket = "wss://" + url + "websocket"
|
||||
} else {
|
||||
@ -171,13 +171,13 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
|
||||
for (key, value) in params! {
|
||||
let keyEsc = key.stringByAddingPercentEncodingWithAllowedCharacters(
|
||||
self.allowedCharacterSet)!
|
||||
allowedCharacterSet)!
|
||||
urlPolling += "&\(keyEsc)="
|
||||
urlWebSocket += "&\(keyEsc)="
|
||||
|
||||
if value is String {
|
||||
let valueEsc = (value as! String).stringByAddingPercentEncodingWithAllowedCharacters(
|
||||
self.allowedCharacterSet)!
|
||||
allowedCharacterSet)!
|
||||
urlPolling += "\(valueEsc)"
|
||||
urlWebSocket += "\(valueEsc)"
|
||||
} else {
|
||||
@ -191,48 +191,48 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
|
||||
private func createWebsocket(andConnect connect:Bool) {
|
||||
self.ws = WebSocket(url: NSURL(string: self.urlWebSocket! + "&sid=\(self.sid)")!,
|
||||
cookies: self.cookies)
|
||||
self.ws?.queue = self.handleQueue
|
||||
self.ws?.delegate = self
|
||||
ws = WebSocket(url: NSURL(string: urlWebSocket! + "&sid=\(sid)")!,
|
||||
cookies: cookies)
|
||||
ws?.queue = handleQueue
|
||||
ws?.delegate = self
|
||||
|
||||
if connect {
|
||||
self.ws?.connect()
|
||||
ws?.connect()
|
||||
}
|
||||
}
|
||||
|
||||
private func doFastUpgrade() {
|
||||
if self.waitingForPoll {
|
||||
if waitingForPoll {
|
||||
SocketLogger.err("Outstanding poll when switched to WebSockets," +
|
||||
"we'll probably disconnect soon. You should report this.", client: self)
|
||||
}
|
||||
|
||||
self.sendWebSocketMessage("", withType: PacketType.UPGRADE, datas: nil)
|
||||
self._websocket = true
|
||||
self._polling = false
|
||||
self.fastUpgrade = false
|
||||
self.probing = false
|
||||
self.flushProbeWait()
|
||||
sendWebSocketMessage("", withType: PacketType.UPGRADE, datas: nil)
|
||||
_websocket = true
|
||||
_polling = false
|
||||
fastUpgrade = false
|
||||
probing = false
|
||||
flushProbeWait()
|
||||
}
|
||||
|
||||
private func doPoll() {
|
||||
if self.websocket || self.waitingForPoll || !self.connected {
|
||||
if websocket || waitingForPoll || !connected {
|
||||
return
|
||||
}
|
||||
|
||||
self.waitingForPoll = true
|
||||
let req = NSMutableURLRequest(URL: NSURL(string: self.urlPolling! + "&sid=\(self.sid)&b64=1")!)
|
||||
waitingForPoll = true
|
||||
let req = NSMutableURLRequest(URL: NSURL(string: urlPolling! + "&sid=\(sid)&b64=1")!)
|
||||
|
||||
if self.cookies != nil {
|
||||
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(self.cookies!)
|
||||
if cookies != nil {
|
||||
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies!)
|
||||
req.allHTTPHeaderFields = headers
|
||||
}
|
||||
|
||||
self.doRequest(req)
|
||||
doRequest(req)
|
||||
}
|
||||
|
||||
private func doRequest(req:NSMutableURLRequest) {
|
||||
if !self.polling {
|
||||
if !polling {
|
||||
return
|
||||
}
|
||||
|
||||
@ -240,7 +240,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
|
||||
SocketLogger.log("Doing polling request", client: self)
|
||||
|
||||
self.session.dataTaskWithRequest(req) {[weak self] data, res, err in
|
||||
session.dataTaskWithRequest(req) {[weak self] data, res, err in
|
||||
if let this = self {
|
||||
if err != nil {
|
||||
if this.polling {
|
||||
@ -272,7 +272,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
private func flushProbeWait() {
|
||||
SocketLogger.log("Flushing probe wait", client: self)
|
||||
|
||||
dispatch_async(self.emitQueue) {[weak self] in
|
||||
dispatch_async(emitQueue) {[weak self] in
|
||||
if let this = self {
|
||||
for waiter in this.probeWait {
|
||||
this.write(waiter.msg, withType: waiter.type, withData: waiter.data)
|
||||
@ -288,27 +288,27 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
|
||||
private func flushWaitingForPost() {
|
||||
if self.postWait.count == 0 || !self.connected {
|
||||
if postWait.count == 0 || !connected {
|
||||
return
|
||||
} else if self.websocket {
|
||||
self.flushWaitingForPostToWebSocket()
|
||||
} else if websocket {
|
||||
flushWaitingForPostToWebSocket()
|
||||
return
|
||||
}
|
||||
|
||||
var postStr = ""
|
||||
|
||||
for packet in self.postWait {
|
||||
for packet in postWait {
|
||||
let len = count(packet)
|
||||
|
||||
postStr += "\(len):\(packet)"
|
||||
}
|
||||
|
||||
self.postWait.removeAll(keepCapacity: false)
|
||||
postWait.removeAll(keepCapacity: false)
|
||||
|
||||
let req = NSMutableURLRequest(URL: NSURL(string: self.urlPolling! + "&sid=\(self.sid)")!)
|
||||
let req = NSMutableURLRequest(URL: NSURL(string: urlPolling! + "&sid=\(sid)")!)
|
||||
|
||||
if self.cookies != nil {
|
||||
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(self.cookies!)
|
||||
if cookies != nil {
|
||||
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies!)
|
||||
req.allHTTPHeaderFields = headers
|
||||
}
|
||||
|
||||
@ -321,11 +321,11 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
req.HTTPBody = postData
|
||||
req.setValue(String(postData.length), forHTTPHeaderField: "Content-Length")
|
||||
|
||||
self.waitingForPost = true
|
||||
waitingForPost = true
|
||||
|
||||
SocketLogger.log("POSTing: \(postStr)", client: self)
|
||||
|
||||
self.session.dataTaskWithRequest(req) {[weak self] data, res, err in
|
||||
session.dataTaskWithRequest(req) {[weak self] data, res, err in
|
||||
if let this = self {
|
||||
if err != nil && this.polling {
|
||||
this.handlePollingFailed(err.localizedDescription)
|
||||
@ -349,63 +349,62 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
// We had packets waiting for send when we upgraded
|
||||
// Send them raw
|
||||
private func flushWaitingForPostToWebSocket() {
|
||||
for msg in self.postWait {
|
||||
self.ws?.writeString(msg)
|
||||
for msg in postWait {
|
||||
ws?.writeString(msg)
|
||||
}
|
||||
|
||||
self.postWait.removeAll(keepCapacity: true)
|
||||
postWait.removeAll(keepCapacity: true)
|
||||
}
|
||||
|
||||
// A poll failed, tell the client about it
|
||||
private func handlePollingFailed(reason:String) {
|
||||
self._connected = false
|
||||
self.ws?.disconnect()
|
||||
self.pingTimer?.invalidate()
|
||||
self.waitingForPoll = false
|
||||
self.waitingForPost = false
|
||||
_connected = false
|
||||
ws?.disconnect()
|
||||
pingTimer?.invalidate()
|
||||
waitingForPoll = false
|
||||
waitingForPost = false
|
||||
|
||||
// If cancelled we were already closing
|
||||
if self.client == nil || reason == "cancelled" {
|
||||
if client == nil || reason == "cancelled" {
|
||||
return
|
||||
}
|
||||
|
||||
if !self.closed {
|
||||
self.client?.didError(reason)
|
||||
self.client?.engineDidClose(reason)
|
||||
if !closed {
|
||||
client?.didError(reason)
|
||||
client?.engineDidClose(reason)
|
||||
}
|
||||
}
|
||||
|
||||
public func open(opts:[String: AnyObject]? = nil) {
|
||||
if self.connected {
|
||||
if connected {
|
||||
SocketLogger.err("Tried to open while connected", client: self)
|
||||
|
||||
self.client?.didError("Tried to open while connected")
|
||||
client?.didError("Tried to open while connected")
|
||||
return
|
||||
}
|
||||
|
||||
SocketLogger.log("Starting engine", client: self)
|
||||
SocketLogger.log("Handshaking", client: self)
|
||||
|
||||
self.closed = false
|
||||
let (urlPolling, urlWebSocket) = self.createURLs(opts)
|
||||
self.urlPolling = urlPolling
|
||||
self.urlWebSocket = urlWebSocket
|
||||
closed = false
|
||||
|
||||
if self.forceWebsockets {
|
||||
self._polling = false
|
||||
self._websocket = true
|
||||
self.createWebsocket(andConnect: true)
|
||||
(urlPolling, urlWebSocket) = createURLs(opts)
|
||||
|
||||
if forceWebsockets {
|
||||
_polling = false
|
||||
_websocket = true
|
||||
createWebsocket(andConnect: true)
|
||||
return
|
||||
}
|
||||
|
||||
let reqPolling = NSMutableURLRequest(URL: NSURL(string: urlPolling + "&b64=1")!)
|
||||
let reqPolling = NSMutableURLRequest(URL: NSURL(string: urlPolling! + "&b64=1")!)
|
||||
|
||||
if self.cookies != nil {
|
||||
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(self.cookies!)
|
||||
if cookies != nil {
|
||||
let headers = NSHTTPCookie.requestHeaderFieldsWithCookies(cookies!)
|
||||
reqPolling.allHTTPHeaderFields = headers
|
||||
}
|
||||
|
||||
self.doRequest(reqPolling)
|
||||
doRequest(reqPolling)
|
||||
}
|
||||
|
||||
// Translatation of engine.io-parser#decodePayload
|
||||
@ -439,7 +438,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
if length == "" || testLength(length, &n) {
|
||||
SocketLogger.err("Parsing error: \(str)", client: self)
|
||||
|
||||
self.handlePollingFailed("Error parsing XHR message")
|
||||
handlePollingFailed("Error parsing XHR message")
|
||||
return
|
||||
}
|
||||
|
||||
@ -454,7 +453,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
|
||||
if msg.length != 0 {
|
||||
// Be sure to capture the value of the msg
|
||||
dispatch_async(self.handleQueue) {[weak self, msg] in
|
||||
dispatch_async(handleQueue) {[weak self, msg] in
|
||||
self?.parseEngineMessage(msg, fromPolling: true)
|
||||
}
|
||||
}
|
||||
@ -466,7 +465,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
|
||||
private func parseEngineData(data:NSData) {
|
||||
if let client = self.client {
|
||||
if let client = client {
|
||||
dispatch_async(client.handleQueue) {[weak self] in
|
||||
self?.client?.parseBinaryData(data.subdataWithRange(NSMakeRange(1, data.length - 1)))
|
||||
}
|
||||
@ -486,17 +485,17 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
// Remove message type
|
||||
message.removeAtIndex(message.startIndex)
|
||||
|
||||
if let client = self.client {
|
||||
if let client = client {
|
||||
dispatch_async(client.handleQueue) {[weak self] in
|
||||
self?.client?.parseSocketMessage(message)
|
||||
}
|
||||
}
|
||||
} else if type == PacketType.NOOP {
|
||||
self.doPoll()
|
||||
doPoll()
|
||||
} else if type == PacketType.PONG {
|
||||
// We should upgrade
|
||||
if message == "3probe" {
|
||||
self.upgradeTransport()
|
||||
upgradeTransport()
|
||||
}
|
||||
} else if type == PacketType.OPEN {
|
||||
var err:NSError?
|
||||
@ -508,32 +507,28 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
options: NSJSONReadingOptions.AllowFragments,
|
||||
error: &err) as? NSDictionary, let sid = json["sid"] as? String {
|
||||
self.sid = sid
|
||||
self._connected = true
|
||||
_connected = true
|
||||
|
||||
if !self.forcePolling && !self.forceWebsockets {
|
||||
self.createWebsocket(andConnect: true)
|
||||
if !forcePolling && !forceWebsockets {
|
||||
createWebsocket(andConnect: true)
|
||||
}
|
||||
|
||||
if let pingInterval = json["pingInterval"] as? Int {
|
||||
self.pingInterval = pingInterval / 1000
|
||||
}
|
||||
} else {
|
||||
self.client?.didError("Engine failed to handshake")
|
||||
client?.didError("Engine failed to handshake")
|
||||
return
|
||||
}
|
||||
|
||||
self.startPingTimer()
|
||||
startPingTimer()
|
||||
|
||||
if !self.forceWebsockets {
|
||||
self.doPoll()
|
||||
if !forceWebsockets {
|
||||
doPoll()
|
||||
}
|
||||
} else if type == PacketType.CLOSE {
|
||||
if self.client == nil {
|
||||
return
|
||||
}
|
||||
|
||||
if self.polling {
|
||||
self.client!.engineDidClose("Disconnect")
|
||||
if polling {
|
||||
client?.engineDidClose("Disconnect")
|
||||
}
|
||||
} else if message.hasPrefix("b4") {
|
||||
// binary in base64 string
|
||||
@ -541,7 +536,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
end: advance(message.startIndex, 2)))
|
||||
|
||||
if let data = NSData(base64EncodedString: message,
|
||||
options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters), client = self.client {
|
||||
options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters), client = client {
|
||||
dispatch_async(client.handleQueue) {[weak self] in
|
||||
self?.client?.parseBinaryData(data)
|
||||
}
|
||||
@ -550,22 +545,22 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
|
||||
private func probeWebSocket() {
|
||||
if self.websocketConnected {
|
||||
self.sendWebSocketMessage("probe", withType: PacketType.PING)
|
||||
if websocketConnected {
|
||||
sendWebSocketMessage("probe", withType: PacketType.PING)
|
||||
}
|
||||
}
|
||||
|
||||
/// Send an engine message (4)
|
||||
public func send(msg:String, withData datas:ContiguousArray<NSData>?) {
|
||||
if self.probing {
|
||||
self.probeWait.append((msg, PacketType.MESSAGE, datas))
|
||||
if probing {
|
||||
probeWait.append((msg, PacketType.MESSAGE, datas))
|
||||
} else {
|
||||
self.write(msg, withType: PacketType.MESSAGE, withData: datas)
|
||||
write(msg, withType: PacketType.MESSAGE, withData: datas)
|
||||
}
|
||||
}
|
||||
|
||||
func sendPing() {
|
||||
self.write("", withType: PacketType.PING, withData: nil)
|
||||
write("", withType: PacketType.PING, withData: nil)
|
||||
}
|
||||
|
||||
/// Send polling message.
|
||||
@ -577,18 +572,18 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
doubleEncodeUTF8(&msg)
|
||||
let strMsg = "\(type.rawValue)\(msg)"
|
||||
|
||||
self.postWait.append(strMsg)
|
||||
postWait.append(strMsg)
|
||||
|
||||
if datas != nil {
|
||||
for data in datas! {
|
||||
let (nilData, b64Data) = self.createBinaryDataForSend(data)
|
||||
let (nilData, b64Data) = createBinaryDataForSend(data)
|
||||
|
||||
self.postWait.append(b64Data!)
|
||||
postWait.append(b64Data!)
|
||||
}
|
||||
}
|
||||
|
||||
if !self.waitingForPost {
|
||||
self.flushWaitingForPost()
|
||||
if !waitingForPost {
|
||||
flushWaitingForPost()
|
||||
}
|
||||
}
|
||||
|
||||
@ -598,13 +593,13 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
datas:ContiguousArray<NSData>? = nil) {
|
||||
SocketLogger.log("Sending ws: \(str) as type: \(type.rawValue)", client: self)
|
||||
|
||||
self.ws?.writeString("\(type.rawValue)\(str)")
|
||||
ws?.writeString("\(type.rawValue)\(str)")
|
||||
|
||||
if datas != nil {
|
||||
for data in datas! {
|
||||
let (data, nilString) = self.createBinaryDataForSend(data)
|
||||
let (data, nilString) = createBinaryDataForSend(data)
|
||||
if data != nil {
|
||||
self.ws?.writeData(data!)
|
||||
ws?.writeData(data!)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -612,11 +607,11 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
|
||||
// Starts the ping timer
|
||||
private func startPingTimer() {
|
||||
if self.pingInterval == nil {
|
||||
if pingInterval == nil {
|
||||
return
|
||||
}
|
||||
|
||||
self.pingTimer?.invalidate()
|
||||
pingTimer?.invalidate()
|
||||
dispatch_async(dispatch_get_main_queue()) {[weak self] in
|
||||
if let this = self {
|
||||
this.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(this.pingInterval!),
|
||||
@ -627,17 +622,16 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
|
||||
func stopPolling() {
|
||||
self.session.invalidateAndCancel()
|
||||
session.invalidateAndCancel()
|
||||
}
|
||||
|
||||
private func upgradeTransport() {
|
||||
if self.websocketConnected {
|
||||
if websocketConnected {
|
||||
SocketLogger.log("Upgrading transport to WebSockets", client: self)
|
||||
|
||||
// Do a fast upgrade
|
||||
// At this point, we should not send anymore polling messages-
|
||||
self.fastUpgrade = true
|
||||
self.sendPollMessage("", withType: PacketType.NOOP)
|
||||
fastUpgrade = true
|
||||
sendPollMessage("", withType: PacketType.NOOP)
|
||||
// After this point, we should not send anymore polling messages
|
||||
}
|
||||
}
|
||||
|
||||
@ -645,7 +639,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
Write a message, independent of transport.
|
||||
*/
|
||||
public func write(msg:String, withType type:PacketType, withData data:ContiguousArray<NSData>?) {
|
||||
dispatch_async(self.emitQueue) {[weak self] in
|
||||
dispatch_async(emitQueue) {[weak self] in
|
||||
if let this = self where this.connected {
|
||||
if this.websocket {
|
||||
SocketLogger.log("Writing ws: \(msg):\(data)", client: this)
|
||||
@ -671,56 +665,56 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
|
||||
}
|
||||
}
|
||||
|
||||
self.write(msg, withType: pType, withData: arr)
|
||||
write(msg, withType: pType, withData: arr)
|
||||
}
|
||||
}
|
||||
|
||||
// Delagate methods
|
||||
|
||||
public func websocketDidConnect(socket:WebSocket) {
|
||||
self.websocketConnected = true
|
||||
websocketConnected = true
|
||||
|
||||
if !self.forceWebsockets {
|
||||
self.probing = true
|
||||
self.probeWebSocket()
|
||||
if !forceWebsockets {
|
||||
probing = true
|
||||
probeWebSocket()
|
||||
} else {
|
||||
self._connected = true
|
||||
self.probing = false
|
||||
self._polling = false
|
||||
_connected = true
|
||||
probing = false
|
||||
_polling = false
|
||||
}
|
||||
}
|
||||
|
||||
public func websocketDidDisconnect(socket:WebSocket, error:NSError?) {
|
||||
self.websocketConnected = false
|
||||
self.probing = false
|
||||
websocketConnected = false
|
||||
probing = false
|
||||
|
||||
if self.closed {
|
||||
self.client?.engineDidClose("Disconnect")
|
||||
if closed {
|
||||
client?.engineDidClose("Disconnect")
|
||||
return
|
||||
}
|
||||
|
||||
if self.websocket {
|
||||
self.pingTimer?.invalidate()
|
||||
self._connected = false
|
||||
self._websocket = false
|
||||
if websocket {
|
||||
pingTimer?.invalidate()
|
||||
_connected = false
|
||||
_websocket = false
|
||||
|
||||
let reason = error?.localizedDescription ?? "Socket Disconnected"
|
||||
|
||||
if error != nil {
|
||||
self.client?.didError(reason)
|
||||
client?.didError(reason)
|
||||
}
|
||||
|
||||
self.client?.engineDidClose(reason)
|
||||
client?.engineDidClose(reason)
|
||||
} else {
|
||||
self.flushProbeWait()
|
||||
flushProbeWait()
|
||||
}
|
||||
}
|
||||
|
||||
public func websocketDidReceiveMessage(socket:WebSocket, text:String) {
|
||||
self.parseEngineMessage(text, fromPolling: false)
|
||||
parseEngineMessage(text, fromPolling: false)
|
||||
}
|
||||
|
||||
public func websocketDidReceiveData(socket:WebSocket, data:NSData) {
|
||||
self.parseEngineData(data)
|
||||
parseEngineData(data)
|
||||
}
|
||||
}
|
||||
|
||||
@ -31,7 +31,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
private var _connecting = false
|
||||
private var currentReconnectAttempt = 0
|
||||
private var handlers = ContiguousArray<SocketEventHandler>()
|
||||
private var params:[String: AnyObject]?
|
||||
private var connectParams:[String: AnyObject]?
|
||||
private var _secure = false
|
||||
private var _sid:String?
|
||||
private var _reconnecting = false
|
||||
@ -50,27 +50,27 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
public let handleQueue = dispatch_queue_create("handleQueue", DISPATCH_QUEUE_SERIAL)
|
||||
public let emitQueue = dispatch_queue_create("emitQueue", DISPATCH_QUEUE_SERIAL)
|
||||
public var closed:Bool {
|
||||
return self._closed
|
||||
return _closed
|
||||
}
|
||||
public var connected:Bool {
|
||||
return self._connected
|
||||
return _connected
|
||||
}
|
||||
public var connecting:Bool {
|
||||
return self._connecting
|
||||
return _connecting
|
||||
}
|
||||
public var engine:SocketEngine?
|
||||
public var nsp = "/"
|
||||
public var opts:[String: AnyObject]?
|
||||
public var reconnects = true
|
||||
public var reconnecting:Bool {
|
||||
return self._reconnecting
|
||||
return _reconnecting
|
||||
}
|
||||
public var reconnectWait = 10
|
||||
public var secure:Bool {
|
||||
return self._secure
|
||||
return _secure
|
||||
}
|
||||
public var sid:String? {
|
||||
return self._sid
|
||||
return _sid
|
||||
}
|
||||
|
||||
/**
|
||||
@ -87,14 +87,13 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
self.socketURL = socketURL
|
||||
self.opts = opts
|
||||
|
||||
|
||||
// Set options
|
||||
if let sessionDelegate = opts?["sessionDelegate"] as? NSURLSessionDelegate {
|
||||
self.sessionDelegate = sessionDelegate
|
||||
}
|
||||
|
||||
if let connectParams = opts?["connectParams"] as? [String: AnyObject] {
|
||||
self.params = connectParams
|
||||
self.connectParams = connectParams
|
||||
}
|
||||
|
||||
if let log = opts?["log"] as? Bool {
|
||||
@ -137,7 +136,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
private func addEngine() {
|
||||
SocketLogger.log("Adding engine", client: self)
|
||||
|
||||
self.engine = SocketEngine(client: self, opts: self.opts)
|
||||
engine = SocketEngine(client: self, opts: opts)
|
||||
}
|
||||
|
||||
/**
|
||||
@ -148,34 +147,34 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
public func close(#fast:Bool) {
|
||||
SocketLogger.log("Closing socket", client: self)
|
||||
|
||||
self.reconnects = false
|
||||
self._connecting = false
|
||||
self._connected = false
|
||||
self._reconnecting = false
|
||||
self.engine?.close(fast: fast)
|
||||
self.engine = nil
|
||||
reconnects = false
|
||||
_connecting = false
|
||||
_connected = false
|
||||
_reconnecting = false
|
||||
engine?.close(fast: fast)
|
||||
engine = nil
|
||||
}
|
||||
|
||||
/**
|
||||
Connect to the server.
|
||||
*/
|
||||
public func connect() {
|
||||
self.connect(timeoutAfter: 0, withTimeoutHandler: nil)
|
||||
connect(timeoutAfter: 0, withTimeoutHandler: nil)
|
||||
}
|
||||
|
||||
/**
|
||||
Connect to the server. If we aren't connected after timeoutAfter, call handler
|
||||
*/
|
||||
public func connect(#timeoutAfter:Int, withTimeoutHandler handler:(() -> Void)?) {
|
||||
if self.closed {
|
||||
if closed {
|
||||
SocketLogger.log("Warning! This socket was previously closed. This might be dangerous!", client: self)
|
||||
self._closed = false
|
||||
} else if self.connected {
|
||||
_closed = false
|
||||
} else if connected {
|
||||
return
|
||||
}
|
||||
|
||||
self.addEngine()
|
||||
self.engine?.open(opts: self.params)
|
||||
addEngine()
|
||||
engine?.open(opts: connectParams)
|
||||
|
||||
if timeoutAfter == 0 {
|
||||
return
|
||||
@ -195,7 +194,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
}
|
||||
|
||||
private func createOnAck(event:String, items:[AnyObject]) -> OnAckCallback {
|
||||
return {[weak self, ack = ++self.currentAck] timeout, callback in
|
||||
return {[weak self, ack = ++currentAck] timeout, callback in
|
||||
if let this = self {
|
||||
this.ackHandlers.addAck(ack, callback: callback)
|
||||
|
||||
@ -217,43 +216,43 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
func didConnect() {
|
||||
SocketLogger.log("Socket connected", client: self)
|
||||
|
||||
self._closed = false
|
||||
self._connected = true
|
||||
self._connecting = false
|
||||
self._reconnecting = false
|
||||
self.currentReconnectAttempt = 0
|
||||
self.reconnectTimer?.invalidate()
|
||||
self.reconnectTimer = nil
|
||||
self._sid = self.engine?.sid
|
||||
_closed = false
|
||||
_connected = true
|
||||
_connecting = false
|
||||
_reconnecting = false
|
||||
currentReconnectAttempt = 0
|
||||
reconnectTimer?.invalidate()
|
||||
reconnectTimer = nil
|
||||
_sid = engine?.sid
|
||||
|
||||
// Don't handle as internal because something crazy could happen where
|
||||
// we disconnect before it's handled
|
||||
self.handleEvent("connect", data: nil, isInternalMessage: false)
|
||||
handleEvent("connect", data: nil, isInternalMessage: false)
|
||||
}
|
||||
|
||||
func didDisconnect(reason:String) {
|
||||
if self.closed {
|
||||
if closed {
|
||||
return
|
||||
}
|
||||
|
||||
SocketLogger.log("Disconnected: \(reason)", client: self)
|
||||
|
||||
self._closed = true
|
||||
self._connected = false
|
||||
self.reconnects = false
|
||||
self._connecting = false
|
||||
self._reconnecting = false
|
||||
_closed = true
|
||||
_connected = false
|
||||
reconnects = false
|
||||
_connecting = false
|
||||
_reconnecting = false
|
||||
|
||||
// Make sure the engine is actually dead.
|
||||
self.engine?.close(fast: true)
|
||||
self.handleEvent("disconnect", data: [reason], isInternalMessage: true)
|
||||
engine?.close(fast: true)
|
||||
handleEvent("disconnect", data: [reason], isInternalMessage: true)
|
||||
}
|
||||
|
||||
/// error
|
||||
public func didError(reason:AnyObject) {
|
||||
SocketLogger.err("Error: \(reason)", client: self)
|
||||
|
||||
self.handleEvent("error", data: reason as? [AnyObject] ?? [reason],
|
||||
handleEvent("error", data: reason as? [AnyObject] ?? [reason],
|
||||
isInternalMessage: true)
|
||||
}
|
||||
|
||||
@ -261,18 +260,18 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
Same as close
|
||||
*/
|
||||
public func disconnect(#fast:Bool) {
|
||||
self.close(fast: fast)
|
||||
close(fast: fast)
|
||||
}
|
||||
|
||||
/**
|
||||
Send a message to the server
|
||||
*/
|
||||
public func emit(event:String, _ items:AnyObject...) {
|
||||
if !self.connected {
|
||||
if !connected {
|
||||
return
|
||||
}
|
||||
|
||||
dispatch_async(self.emitQueue) {[weak self] in
|
||||
dispatch_async(emitQueue) {[weak self] in
|
||||
self?._emit(event, items)
|
||||
}
|
||||
}
|
||||
@ -281,11 +280,11 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
Same as emit, but meant for Objective-C
|
||||
*/
|
||||
public func emit(event:String, withItems items:[AnyObject]) {
|
||||
if !self.connected {
|
||||
if !connected {
|
||||
return
|
||||
}
|
||||
|
||||
dispatch_async(self.emitQueue) {[weak self] in
|
||||
dispatch_async(emitQueue) {[weak self] in
|
||||
self?._emit(event, items)
|
||||
}
|
||||
}
|
||||
@ -295,30 +294,30 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
an ack.
|
||||
*/
|
||||
public func emitWithAck(event:String, _ items:AnyObject...) -> OnAckCallback {
|
||||
if !self.connected {
|
||||
if !connected {
|
||||
return createOnAck(event, items: items)
|
||||
}
|
||||
|
||||
return self.createOnAck(event, items: items)
|
||||
return createOnAck(event, items: items)
|
||||
}
|
||||
|
||||
/**
|
||||
Same as emitWithAck, but for Objective-C
|
||||
*/
|
||||
public func emitWithAck(event:String, withItems items:[AnyObject]) -> OnAckCallback {
|
||||
if !self.connected {
|
||||
return self.createOnAck(event, items: items)
|
||||
if !connected {
|
||||
return createOnAck(event, items: items)
|
||||
}
|
||||
|
||||
return self.createOnAck(event, items: items)
|
||||
return createOnAck(event, items: items)
|
||||
}
|
||||
|
||||
private func _emit(event:String, _ args:[AnyObject], ack:Int? = nil) {
|
||||
if !self.connected {
|
||||
if !connected {
|
||||
return
|
||||
}
|
||||
|
||||
let packet = SocketPacket(type: nil, data: args, nsp: self.nsp, id: ack)
|
||||
let packet = SocketPacket(type: nil, data: args, nsp: nsp, id: ack)
|
||||
let str:String
|
||||
|
||||
SocketParser.parseForEmit(packet)
|
||||
@ -327,15 +326,15 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
SocketLogger.log("Emitting: \(str)", client: self)
|
||||
|
||||
if packet.type == SocketPacket.PacketType.BINARY_EVENT {
|
||||
self.engine?.send(str, withData: packet.binary)
|
||||
engine?.send(str, withData: packet.binary)
|
||||
} else {
|
||||
self.engine?.send(str, withData: nil)
|
||||
engine?.send(str, withData: nil)
|
||||
}
|
||||
}
|
||||
|
||||
// If the server wants to know that the client received data
|
||||
func emitAck(ack:Int, withData args:[AnyObject]) {
|
||||
dispatch_async(self.emitQueue) {[weak self] in
|
||||
dispatch_async(emitQueue) {[weak self] in
|
||||
if let this = self where this.connected {
|
||||
let packet = SocketPacket(type: nil, data: args, nsp: this.nsp, id: ack)
|
||||
let str:String
|
||||
@ -356,14 +355,14 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
}
|
||||
|
||||
public func engineDidClose(reason:String) {
|
||||
self._connected = false
|
||||
self._connecting = false
|
||||
_connected = false
|
||||
_connecting = false
|
||||
|
||||
if self.closed || !self.reconnects {
|
||||
self.didDisconnect("Engine closed")
|
||||
} else if !self.reconnecting {
|
||||
self.handleEvent("reconnect", data: [reason], isInternalMessage: true)
|
||||
self.tryReconnect()
|
||||
if closed || !reconnects {
|
||||
didDisconnect("Engine closed")
|
||||
} else if !reconnecting {
|
||||
handleEvent("reconnect", data: [reason], isInternalMessage: true)
|
||||
tryReconnect()
|
||||
}
|
||||
}
|
||||
|
||||
@ -371,7 +370,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
func handleAck(ack:Int, data:AnyObject?) {
|
||||
SocketLogger.log("Handling ack: \(ack) with data: \(data)", client: self)
|
||||
|
||||
self.ackHandlers.executeAck(ack,
|
||||
ackHandlers.executeAck(ack,
|
||||
items: (data as? [AnyObject]?) ?? (data != nil ? [data!] : nil))
|
||||
}
|
||||
|
||||
@ -381,19 +380,19 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
public func handleEvent(event:String, data:[AnyObject]?, isInternalMessage:Bool = false,
|
||||
wantsAck ack:Int? = nil) {
|
||||
// println("Should do event: \(event) with data: \(data)")
|
||||
if !self.connected && !isInternalMessage {
|
||||
if !connected && !isInternalMessage {
|
||||
return
|
||||
}
|
||||
|
||||
SocketLogger.log("Handling event: \(event) with data: \(data)", client: self)
|
||||
|
||||
if self.anyHandler != nil {
|
||||
if anyHandler != nil {
|
||||
dispatch_async(dispatch_get_main_queue()) {[weak self] in
|
||||
self?.anyHandler?(SocketAnyEvent(event: event, items: data))
|
||||
}
|
||||
}
|
||||
|
||||
for handler in self.handlers {
|
||||
for handler in handlers {
|
||||
if handler.event == event {
|
||||
if ack != nil {
|
||||
handler.executeCallback(data, withAck: ack!, withSocket: self)
|
||||
@ -408,9 +407,9 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
Leaves nsp and goes back to /
|
||||
*/
|
||||
public func leaveNamespace() {
|
||||
if self.nsp != "/" {
|
||||
self.engine?.send("1/\(self.nsp)", withData: nil)
|
||||
self.nsp = "/"
|
||||
if nsp != "/" {
|
||||
engine?.send("1/\(nsp)", withData: nil)
|
||||
nsp = "/"
|
||||
}
|
||||
}
|
||||
|
||||
@ -420,8 +419,8 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
public func joinNamespace() {
|
||||
SocketLogger.log("Joining namespace", client: self)
|
||||
|
||||
if self.nsp != "/" {
|
||||
self.engine?.send("0/\(self.nsp)", withData: nil)
|
||||
if nsp != "/" {
|
||||
engine?.send("0/\(nsp)", withData: nil)
|
||||
}
|
||||
}
|
||||
|
||||
@ -431,7 +430,7 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
public func off(event:String) {
|
||||
SocketLogger.log("Removing handler for event: \(event)", client: self)
|
||||
|
||||
self.handlers = self.handlers.filter {$0.event == event ? false : true}
|
||||
handlers = handlers.filter {$0.event == event ? false : true}
|
||||
}
|
||||
|
||||
/**
|
||||
@ -441,21 +440,21 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
SocketLogger.log("Adding handler for event: \(name)", client: self)
|
||||
|
||||
let handler = SocketEventHandler(event: name, callback: callback)
|
||||
self.handlers.append(handler)
|
||||
handlers.append(handler)
|
||||
}
|
||||
|
||||
/**
|
||||
Adds a handler that will be called on every event.
|
||||
*/
|
||||
public func onAny(handler:(SocketAnyEvent) -> Void) {
|
||||
self.anyHandler = handler
|
||||
anyHandler = handler
|
||||
}
|
||||
|
||||
/**
|
||||
Same as connect
|
||||
*/
|
||||
public func open() {
|
||||
self.connect()
|
||||
connect()
|
||||
}
|
||||
|
||||
public func parseSocketMessage(msg:String) {
|
||||
@ -470,29 +469,29 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
Trieds to reconnect to the server.
|
||||
*/
|
||||
public func reconnect() {
|
||||
self._connected = false
|
||||
self._connecting = false
|
||||
self._reconnecting = false
|
||||
_connected = false
|
||||
_connecting = false
|
||||
_reconnecting = false
|
||||
|
||||
self.engine?.stopPolling()
|
||||
self.tryReconnect()
|
||||
engine?.stopPolling()
|
||||
tryReconnect()
|
||||
}
|
||||
|
||||
// We lost connection and should attempt to reestablish
|
||||
@objc private func tryReconnect() {
|
||||
if self.reconnectAttempts != -1 && self.currentReconnectAttempt + 1 > self.reconnectAttempts {
|
||||
self.didDisconnect("Reconnect Failed")
|
||||
if reconnectAttempts != -1 && currentReconnectAttempt + 1 > reconnectAttempts {
|
||||
didDisconnect("Reconnect Failed")
|
||||
return
|
||||
} else if self.connected {
|
||||
self._connecting = false
|
||||
self._reconnecting = false
|
||||
} else if connected {
|
||||
_connecting = false
|
||||
_reconnecting = false
|
||||
return
|
||||
}
|
||||
|
||||
if self.reconnectTimer == nil {
|
||||
if reconnectTimer == nil {
|
||||
SocketLogger.log("Starting reconnect", client: self)
|
||||
|
||||
self._reconnecting = true
|
||||
_reconnecting = true
|
||||
|
||||
dispatch_async(dispatch_get_main_queue()) {[weak self] in
|
||||
if let this = self {
|
||||
@ -503,10 +502,10 @@ public final class SocketIOClient: NSObject, SocketEngineClient, SocketLogClient
|
||||
}
|
||||
|
||||
SocketLogger.log("Trying to reconnect", client: self)
|
||||
self.handleEvent("reconnectAttempt", data: [self.reconnectAttempts - self.currentReconnectAttempt],
|
||||
handleEvent("reconnectAttempt", data: [reconnectAttempts - currentReconnectAttempt],
|
||||
isInternalMessage: true)
|
||||
|
||||
self.currentReconnectAttempt++
|
||||
self.connect()
|
||||
currentReconnectAttempt++
|
||||
connect()
|
||||
}
|
||||
}
|
||||
|
||||
@ -32,10 +32,10 @@ final class SocketPacket: Printable {
|
||||
var better = "SocketPacket {type: ~~0; data: ~~1; " +
|
||||
"id: ~~2; placeholders: ~~3;}"
|
||||
|
||||
better = better["~~0"] ~= (self.type != nil ? String(self.type!.rawValue) : "nil")
|
||||
better = better["~~1"] ~= (self.data != nil ? "\(self.data!)" : "nil")
|
||||
better = better["~~2"] ~= (self.id != nil ? String(self.id!) : "nil")
|
||||
better = better["~~3"] ~= (self.placeholders != nil ? String(self.placeholders!) : "nil")
|
||||
better = better["~~0"] ~= (type != nil ? String(type!.rawValue) : "nil")
|
||||
better = better["~~1"] ~= (data != nil ? "\(data!)" : "nil")
|
||||
better = better["~~2"] ~= (id != nil ? String(id!) : "nil")
|
||||
better = better["~~3"] ~= (placeholders != nil ? String(placeholders!) : "nil")
|
||||
|
||||
return better
|
||||
}
|
||||
@ -77,15 +77,15 @@ final class SocketPacket: Printable {
|
||||
}
|
||||
|
||||
func addData(data:NSData) -> Bool {
|
||||
if self.placeholders == self.currentPlace {
|
||||
if placeholders == currentPlace {
|
||||
return true
|
||||
}
|
||||
|
||||
self.binary.append(data)
|
||||
self.currentPlace++
|
||||
binary.append(data)
|
||||
currentPlace++
|
||||
|
||||
if self.placeholders == self.currentPlace {
|
||||
self.currentPlace = 0
|
||||
if placeholders == currentPlace {
|
||||
currentPlace = 0
|
||||
return true
|
||||
} else {
|
||||
return false
|
||||
@ -95,77 +95,77 @@ final class SocketPacket: Printable {
|
||||
func createMessageForEvent(event:String) -> String {
|
||||
let message:String
|
||||
|
||||
if self.binary.count == 0 {
|
||||
self.type = PacketType.EVENT
|
||||
if binary.count == 0 {
|
||||
type = PacketType.EVENT
|
||||
|
||||
if self.nsp == "/" {
|
||||
if self.id == nil {
|
||||
if nsp == "/" {
|
||||
if id == nil {
|
||||
message = "2[\"\(event)\""
|
||||
} else {
|
||||
message = "2\(self.id!)[\"\(event)\""
|
||||
message = "2\(id!)[\"\(event)\""
|
||||
}
|
||||
} else {
|
||||
if self.id == nil {
|
||||
message = "2/\(self.nsp),[\"\(event)\""
|
||||
if id == nil {
|
||||
message = "2/\(nsp),[\"\(event)\""
|
||||
} else {
|
||||
message = "2/\(self.nsp),\(self.id!)[\"\(event)\""
|
||||
message = "2/\(nsp),\(id!)[\"\(event)\""
|
||||
}
|
||||
}
|
||||
} else {
|
||||
self.type = PacketType.BINARY_EVENT
|
||||
type = PacketType.BINARY_EVENT
|
||||
|
||||
if self.nsp == "/" {
|
||||
if self.id == nil {
|
||||
message = "5\(self.binary.count)-[\"\(event)\""
|
||||
if nsp == "/" {
|
||||
if id == nil {
|
||||
message = "5\(binary.count)-[\"\(event)\""
|
||||
} else {
|
||||
message = "5\(self.binary.count)-\(self.id!)[\"\(event)\""
|
||||
message = "5\(binary.count)-\(id!)[\"\(event)\""
|
||||
}
|
||||
} else {
|
||||
if self.id == nil {
|
||||
message = "5\(self.binary.count)-/\(self.nsp),[\"\(event)\""
|
||||
if id == nil {
|
||||
message = "5\(binary.count)-/\(nsp),[\"\(event)\""
|
||||
} else {
|
||||
message = "5\(self.binary.count)-/\(self.nsp),\(self.id!)[\"\(event)\""
|
||||
message = "5\(binary.count)-/\(nsp),\(id!)[\"\(event)\""
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return self.completeMessage(message)
|
||||
return completeMessage(message)
|
||||
}
|
||||
|
||||
func createAck() -> String {
|
||||
var msg:String
|
||||
|
||||
if self.binary.count == 0 {
|
||||
self.type = PacketType.ACK
|
||||
if binary.count == 0 {
|
||||
type = PacketType.ACK
|
||||
|
||||
if nsp == "/" {
|
||||
msg = "3\(self.id!)["
|
||||
msg = "3\(id!)["
|
||||
} else {
|
||||
msg = "3/\(self.nsp),\(self.id!)["
|
||||
msg = "3/\(nsp),\(id!)["
|
||||
}
|
||||
} else {
|
||||
self.type = PacketType.BINARY_ACK
|
||||
type = PacketType.BINARY_ACK
|
||||
|
||||
if nsp == "/" {
|
||||
msg = "6\(self.binary.count)-\(self.id!)["
|
||||
msg = "6\(binary.count)-\(id!)["
|
||||
} else {
|
||||
msg = "6\(self.binary.count)-/\(self.nsp),\(self.id!)["
|
||||
msg = "6\(binary.count)-/\(nsp),\(id!)["
|
||||
}
|
||||
}
|
||||
|
||||
return self.completeMessage(msg, ack: true)
|
||||
return completeMessage(msg, ack: true)
|
||||
}
|
||||
|
||||
private func completeMessage(var message:String, ack:Bool = false) -> String {
|
||||
var err:NSError?
|
||||
|
||||
if self.data == nil || self.data!.count == 0 {
|
||||
if data == nil || data!.count == 0 {
|
||||
return message + "]"
|
||||
} else if !ack {
|
||||
message += ","
|
||||
}
|
||||
|
||||
for arg in self.data! {
|
||||
for arg in data! {
|
||||
if arg is NSDictionary || arg is [AnyObject] {
|
||||
let jsonSend = NSJSONSerialization.dataWithJSONObject(arg,
|
||||
options: NSJSONWritingOptions(0), error: &err)
|
||||
@ -189,23 +189,23 @@ final class SocketPacket: Printable {
|
||||
}
|
||||
|
||||
func fillInPlaceholders() {
|
||||
var newArr = NSMutableArray(array: self.data!)
|
||||
var newArr = NSMutableArray(array: data!)
|
||||
|
||||
for i in 0..<self.data!.count {
|
||||
if let str = self.data?[i] as? String, num = str["~~(\\d)"].groups() {
|
||||
newArr[i] = self.binary[num[1].toInt()!]
|
||||
} else if self.data?[i] is NSDictionary || self.data?[i] is NSArray {
|
||||
newArr[i] = self._fillInPlaceholders(self.data![i])
|
||||
for i in 0..<data!.count {
|
||||
if let str = data?[i] as? String, num = str["~~(\\d)"].groups() {
|
||||
newArr[i] = binary[num[1].toInt()!]
|
||||
} else if data?[i] is NSDictionary || data?[i] is NSArray {
|
||||
newArr[i] = _fillInPlaceholders(data![i])
|
||||
}
|
||||
}
|
||||
|
||||
self.data = newArr as [AnyObject]
|
||||
data = newArr as [AnyObject]
|
||||
}
|
||||
|
||||
private func _fillInPlaceholders(data:AnyObject) -> AnyObject {
|
||||
if let str = data as? String {
|
||||
if let num = str["~~(\\d)"].groups() {
|
||||
return self.binary[num[1].toInt()!]
|
||||
return binary[num[1].toInt()!]
|
||||
} else {
|
||||
return str
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user