Add acks, still needs more testing

SwiftIO/SocketAckHandler.swift

@@ -0,0 +1,45 @@
+//
+//  SocketAckHandler.swift
+//  Socket.IO-Swift
+//
+//  Created by Erik Little on 2/14/15.
+
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+
+import Foundation
+
+typealias AckCallback = ([AnyObject]?) -> Void
+
+class SocketAckHandler {
+    let event:String!
+    var ackData:[AnyObject]?
+    var callback:AckCallback?
+    
+    init(event:String) {
+        self.event = event
+    }
+    
+    func onAck(callback:AckCallback) {
+        self.callback = callback
+    }
+    
+    func ackWith(data:AnyObject...) {
+        self.ackData = data
+    }
+}

SwiftIO/SocketEvent.swift

@@ -25,16 +25,18 @@
 import Foundation
 
 class SocketEvent {
+    var ack:Int?
     var args:AnyObject!
     lazy var currentPlace = 0
     lazy var datas = [NSData]()
     var event:String!
     var placeholders:Int!
     
-    init(event:String, args:AnyObject?, placeholders:Int = 0) {
+    init(event:String, args:AnyObject?, placeholders:Int = 0, ack:Int? = nil) {
         self.event = event
         self.args = args
         self.placeholders = placeholders
+        self.ack = ack
     }
     
     func addData(data:NSData) -> Bool {
@@ -61,7 +63,7 @@ class SocketEvent {
         }
     }
     
-    class func createMessageForEvent(event:String, withArgs args:[AnyObject],
+    static func createMessageForEvent(event:String, withArgs args:[AnyObject],
         hasBinary:Bool, withDatas datas:Int = 0, toNamespace nsp:String?) -> String {
             
             var message:String
@@ -69,39 +71,78 @@ class SocketEvent {
             
             if !hasBinary {
                 if nsp == nil {
-                    message = "42[\"\(event)\""
+                    message = "42[\"\(event)\","
                 } else {
-                    message = "42/\(nsp!),[\"\(event)\""
+                    message = "42/\(nsp!),[\"\(event)\","
                 }
             } else {
                 if nsp == nil {
-                    message = "45\(datas)-[\"\(event)\""
+                    message = "45\(datas)-[\"\(event)\","
                 } else {
-                    message = "45\(datas)-/\(nsp!),[\"\(event)\""
+                    message = "45\(datas)-/\(nsp!),[\"\(event)\","
                 }
             }
             
-            for arg in args {
+            return self.completeMessage(message, args: args)
-                message += ","
+    }
-                
+    
-                if arg is NSDictionary || arg is [AnyObject] {
+    static func createAck(ack:Int, withEvent event:String, withArgs args:[AnyObject],
-                    let jsonSend = NSJSONSerialization.dataWithJSONObject(arg,
+        withAckType ackType:Int, withNsp nsp:String, withBinary binary:Int = 0) -> String {
-                        options: NSJSONWritingOptions(0), error: &jsonSendError)
+            var msg:String
-                    let jsonString = NSString(data: jsonSend!, encoding: NSUTF8StringEncoding)
+            
+            if ackType == 3 {
+                if nsp == "/" {
+                    msg = "43\(ack)["
                     
-                    message += jsonString! as! String
+                    return self.completeMessage(msg, args: args)
-                    continue
+                    
+                } else {
+                    msg = "43\(nsp)["
+                    
+                    return self.completeMessage(msg, args: args)
                 }
-                
+            } else {
-                if arg is String {
+                if nsp == "/" {
-                    message += "\"\(arg)\""
+                    msg = "46\(binary)-\(ack)[\"\(event)\""
-                    continue
+                    
+                    return self.completeMessage(msg, args: args)
+                    
+                } else {
+                    msg = "46\(binary)-\(nsp),\(ack)[\"\(event)\""
+                    
+                    return self.completeMessage(msg, args: args)
                 }
+            }
+    }
+    
+    private static func completeMessage(var message:String, args:[AnyObject]) -> String {
+        var err:NSError?
+        for arg in args {
+            
+            if arg is NSDictionary || arg is [AnyObject] {
+                let jsonSend = NSJSONSerialization.dataWithJSONObject(arg,
+                    options: NSJSONWritingOptions(0), error: &err)
+                let jsonString = NSString(data: jsonSend!, encoding: NSUTF8StringEncoding)
                 
-                message += "\(arg)"
+                message += jsonString! as! String
+                message += ","
+                continue
             }
             
-            return message + "]"
+            if arg is String {
+                message += "\"\(arg)\""
+                message += ","
+                continue
+            }
+            
+            message += "\(arg)"
+            message += ","
+        }
+        
+        if message != "" {
+            message.removeAtIndex(message.endIndex.predecessor())
+        }
+        return message + "]"
     }
     
     private func fillInArray(arr:NSArray) -> NSArray {

SwiftIO/SocketEventHandler.swift

@@ -23,22 +23,25 @@
 //  THE SOFTWARE.
 
 class SocketEventHandler {
+    let ack:SocketAckHandler!
     let event:String!
     let callback:NormalCallback?
     let callbackMult:MultipleCallback?
     var multiEvent = false
     
-    init(event:String, callback:NormalCallback) {
+    init(event:String, callback:NormalCallback, ack:SocketAckHandler) {
         self.event = event
         self.callback = callback
         self.callbackMult = nil
+        self.ack = ack
     }
     
-    init(event:String, callback:MultipleCallback) {
+    init(event:String, callback:MultipleCallback, ack:SocketAckHandler) {
         self.event = event
         self.callbackMult = callback
         self.callback = nil
         self.multiEvent = true
+        self.ack = ack
     }
     
     func executeCallback(item:AnyObject?, items:NSArray? = nil) {

SwiftIO/SocketIOClient.swift

@@ -29,10 +29,13 @@ typealias MultipleCallback = (NSArray?) -> Void
 
 class SocketIOClient: NSObject, SRWebSocketDelegate {
     let socketURL:NSMutableString!
+    let ackQueue = dispatch_queue_create("ackQueue".cStringUsingEncoding(NSUTF8StringEncoding),
+        DISPATCH_QUEUE_SERIAL)
     let handleQueue = dispatch_queue_create("handleQueue".cStringUsingEncoding(NSUTF8StringEncoding),
         DISPATCH_QUEUE_SERIAL)
     let emitQueue = dispatch_queue_create("emitQueue".cStringUsingEncoding(NSUTF8StringEncoding),
         DISPATCH_QUEUE_SERIAL)
+    private var ackHandlers = [SocketAckHandler]()
     private var secure = false
     private var handlers = [SocketEventHandler]()
     private var lastSocketMessage:SocketEvent?
@@ -123,65 +126,30 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
     // Sends a message with multiple args
     // If a message contains binary we have to send those
     // seperately.
-    func emit(event:String, _ args:AnyObject...) {
+    func emit(event:String, _ args:AnyObject...) -> SocketAckHandler {
         if !self.connected {
-            return
+            return SocketAckHandler(event: "fail")
         }
         
-        dispatch_async(self.emitQueue) {self._emit(event, args)}
+        let ackHandler = SocketAckHandler(event: event)
+        self.ackHandlers.append(ackHandler)
+        
+        dispatch_async(self.emitQueue) {[weak self] in
+            if self == nil {
+                return
+            }
+            
+            self?._emit(event, args)
+        }
+        
+        return ackHandler
     }
     
     private func _emit(event:String, _ args:[AnyObject]) {
         var frame:SocketEvent
         var str:String
-        var items = [AnyObject](count: args.count, repeatedValue: 1)
-        var numberOfPlaceholders = -1
-        var hasBinary = false
-        var emitDatas = [NSData]()
         
-        for i in 0..<args.count {
+        let (items, hasBinary, emitDatas) = SocketIOClient.parseEmitArgs(args)
-            if let dict = args[i] as? NSDictionary {
-                // Check for binary data
-                let (newDict, hadBinary, binaryDatas) = SocketIOClient.parseNSDictionary(dict,
-                    placeholders: numberOfPlaceholders)
-                if hadBinary {
-                    numberOfPlaceholders = binaryDatas.count
-                    
-                    emitDatas.extend(binaryDatas)
-                    hasBinary = true
-                    items[i] = newDict
-                } else {
-                    items[i] = dict
-                }
-            } else if let arr = args[i] as? NSArray {
-                // arg is array, check for binary
-                let (replace, hadData, newDatas) = SocketIOClient.parseArray(arr,
-                    placeholders: numberOfPlaceholders)
-                
-                if hadData {
-                    hasBinary = true
-                    numberOfPlaceholders += emitDatas.count
-                    
-                    for data in newDatas {
-                        emitDatas.append(data)
-                    }
-                    
-                    items[i] = replace
-                } else {
-                    items[i] = arr
-                }
-            } else if let binaryData = args[i] as? NSData {
-                // args is just binary
-                hasBinary = true
-                let sendData = SocketIOClient.createBinaryDataForSend(binaryData)
-                
-                numberOfPlaceholders++
-                items[i] = ["_placeholder": true, "num": numberOfPlaceholders]
-                emitDatas.append(sendData)
-            } else {
-                items[i] = args[i]
-            }
-        }
         
         if !self.connected {
             return
@@ -202,25 +170,66 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
         }
     }
     
-    // Handles events
+    // If the server wants to know that the client received data
-    func handleEvent(event:String, data:AnyObject?, multipleItems:Bool = false, internalMessage:Bool = false) {
+    private func emitAck(ack:Int, withEvent event:String, withData data:[AnyObject]?, withAckType ackType:Int) {
-        // println("Should do event: \(event) with data: \(data)")
+        dispatch_async(self.ackQueue) {[weak self] in
-        if !self.connected && !internalMessage {
+            if self == nil || !self!.connected || data == nil {
-            return
+                return
-        }
+            }
-        
+            
-        for handler in self.handlers {
+            let (items, hasBinary, emitDatas) = SocketIOClient.parseEmitArgs(data!)
-            if handler.event == event {
+            var str:String
-                if data is NSArray {
+            
-                    handler.executeCallback(nil, items: (data as! NSArray))
+            if !hasBinary {
-                    
+                if self?.nsp == nil {
+                    str = SocketEvent.createAck(ack, withEvent: event, withArgs: items, withAckType: 3, withNsp: "/")
                 } else {
-                    handler.executeCallback(data)
+                    str = SocketEvent.createAck(ack, withEvent: event, withArgs: items, withAckType: 3, withNsp: self!.nsp!)
+                }
+                
+                self?.io?.send(str)
+            } else {
+                if self?.nsp == nil {
+                    str = SocketEvent.createAck(ack, withEvent: event, withArgs: items, withAckType: 6, withNsp: "/")
+                } else {
+                    str = SocketEvent.createAck(ack, withEvent: event, withArgs: items, withAckType: 6, withNsp: self!.nsp!)
+                }
+                
+                self?.io?.send(str)
+                for data in emitDatas {
+                    self?.io?.send(data)
                 }
             }
         }
     }
     
+    // Handles events
+    func handleEvent(event:String, data:AnyObject?, isInternalMessage:Bool = false,
+        wantsAck ack:Int? = nil, withAckType ackType:Int = 3) {
+            // println("Should do event: \(event) with data: \(data)")
+            if !self.connected && !isInternalMessage {
+                return
+            }
+            
+            for handler in self.handlers {
+                if handler.event == event {
+                    if data is NSArray {
+                        handler.executeCallback(nil, items: (data as! NSArray))
+                        if ack != nil {
+                            self.emitAck(ack!, withEvent: event,
+                                withData: handler.ack.ackData, withAckType: ackType)
+                        }
+                    } else {
+                        handler.executeCallback(data)
+                        if ack != nil {
+                            self.emitAck(ack!, withEvent: event,
+                                withData: handler.ack.ackData, withAckType: ackType)
+                        }
+                    }
+                }
+            }
+    }
+    
     private func joinNamespace() {
         if self.nsp != nil {
             self.io?.send("40/\(self.nsp!)")
@@ -228,15 +237,21 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
     }
     
     // Adds handler for single arg message
-    func on(name:String, callback:NormalCallback) {
+    func on(name:String, callback:NormalCallback) -> SocketAckHandler {
-        let handler = SocketEventHandler(event: name, callback: callback)
+        let ackHandler = SocketAckHandler(event: name)
+        let handler = SocketEventHandler(event: name, callback: callback, ack: ackHandler)
         self.handlers.append(handler)
+        
+        return ackHandler
     }
     
     // Adds handler for multiple arg message
-    func onMultipleItems(name:String, callback:MultipleCallback) {
+    func onMultipleItems(name:String, callback:MultipleCallback) -> SocketAckHandler {
-        let handler = SocketEventHandler(event: name, callback: callback)
+        let ackHandler = SocketAckHandler(event: name)
+        let handler = SocketEventHandler(event: name, callback: callback, ack: ackHandler)
         self.handlers.append(handler)
+        
+        return ackHandler
     }
     
     // Opens the connection to the socket
@@ -294,7 +309,7 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
     }
     
     // Parses data for events
-    class func parseData(data:String?) -> AnyObject? {
+    static func parseData(data:String?) -> AnyObject? {
         if data == nil {
             return nil
         }
@@ -312,8 +327,61 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
         return parsed
     }
     
+    private static func parseEmitArgs(args:[AnyObject]) -> ([AnyObject], Bool, [NSData]) {
+        var items = [AnyObject](count: args.count, repeatedValue: 1)
+        var numberOfPlaceholders = -1
+        var hasBinary = false
+        var emitDatas = [NSData]()
+        
+        for i in 0..<args.count {
+            if let dict = args[i] as? NSDictionary {
+                // Check for binary data
+                let (newDict, hadBinary, binaryDatas) = SocketIOClient.parseNSDictionary(dict,
+                    placeholders: numberOfPlaceholders)
+                if hadBinary {
+                    numberOfPlaceholders = binaryDatas.count
+                    
+                    emitDatas.extend(binaryDatas)
+                    hasBinary = true
+                    items[i] = newDict
+                } else {
+                    items[i] = dict
+                }
+            } else if let arr = args[i] as? NSArray {
+                // arg is array, check for binary
+                let (replace, hadData, newDatas) = SocketIOClient.parseArray(arr,
+                    placeholders: numberOfPlaceholders)
+                
+                if hadData {
+                    hasBinary = true
+                    numberOfPlaceholders += emitDatas.count
+                    
+                    for data in newDatas {
+                        emitDatas.append(data)
+                    }
+                    
+                    items[i] = replace
+                } else {
+                    items[i] = arr
+                }
+            } else if let binaryData = args[i] as? NSData {
+                // args is just binary
+                hasBinary = true
+                let sendData = SocketIOClient.createBinaryDataForSend(binaryData)
+                
+                numberOfPlaceholders++
+                items[i] = ["_placeholder": true, "num": numberOfPlaceholders]
+                emitDatas.append(sendData)
+            } else {
+                items[i] = args[i]
+            }
+        }
+        
+        return (items, hasBinary, emitDatas)
+    }
+    
     // Parses a NSDictionary, looking for NSData objects
-    private class func parseNSDictionary(dict:NSDictionary, var placeholders:Int) -> (NSDictionary, Bool, [NSData]) {
+    private static func parseNSDictionary(dict:NSDictionary, var placeholders:Int) -> (NSDictionary, Bool, [NSData]) {
         var returnDict = NSMutableDictionary()
         var hasBinary = false
         if placeholders == -1 {
@@ -400,17 +468,25 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
             /**
             Begin check for message
             **/
-            let messageGroups = mutMessage["(\\d*)\\/?(\\w*)?,?(\\[.*\\])?"].groups()
+            let messageGroups = mutMessage["(\\d*)\\/?(\\w*)?,?(\\d*)?(\\[.*\\])?"].groups()
             
-            if messageGroups[1] == "42" {
+            if messageGroups[1].hasPrefix("42") {
+                var mesNum = messageGroups[1]
+                var ackNum:String
                 var namespace:String?
                 var messagePart:String!
                 
-                if messageGroups.count == 4 {
+                if messageGroups[3] != "" {
-                    namespace = messageGroups[2]
+                    ackNum = messageGroups[3]
-                    messagePart = messageGroups[3]
+                } else {
+                    let range = Range<String.Index>(start: mesNum.startIndex, end: advance(mesNum.startIndex, 2))
+                    mesNum.replaceRange(range, with: "")
+                    ackNum = mesNum
                 }
                 
+                namespace = messageGroups[2]
+                messagePart = messageGroups[4]
+                
                 if namespace == "" && self.nsp != nil {
                     return
                 }
@@ -429,7 +505,12 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
                     // It would be nice if socket.io only allowed one thing
                     // per message, but alas, it doesn't.
                     if let parsed:AnyObject = SocketIOClient.parseData(data) {
-                        self.handleEvent(event, data: parsed)
+                        if ackNum == "" {
+                            self.handleEvent(event, data: parsed)
+                        } else {
+                            self.handleEvent(event, data: parsed, isInternalMessage: false,
+                                wantsAck: ackNum.toInt(), withAckType: 3)
+                        }
                         return
                     } else if let strData = data {
                         // There are multiple items in the message
@@ -437,7 +518,12 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
                         // parseData to try and get an array.
                         let asArray = "[\(strData)]"
                         if let parsed:AnyObject = SocketIOClient.parseData(asArray) {
-                            self.handleEvent(event, data: parsed, multipleItems: true)
+                            if ackNum == "" {
+                                self.handleEvent(event, data: parsed)
+                            } else {
+                                self.handleEvent(event, data: parsed, isInternalMessage: false,
+                                    wantsAck: ackNum.toInt(), withAckType: 3)
+                            }
                             return
                         }
                     }
@@ -447,7 +533,12 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
                 let noItemMessage = RegexMutable(messagePart)["\\[\"(.*?)\"]$"].groups()
                 if noItemMessage != nil && noItemMessage.count == 2 {
                     let event = noItemMessage[1]
-                    self.handleEvent(event, data: nil, multipleItems: false)
+                    if ackNum == "" {
+                        self.handleEvent(event, data: nil)
+                    } else {
+                        self.handleEvent(event, data: nil, isInternalMessage: false,
+                            wantsAck: ackNum.toInt(), withAckType: 3)
+                    }
                     return
                 }
             }
@@ -479,23 +570,30 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
             /**
             Begin check for binary placeholders
             **/
-            let binaryGroup = mutMessage["(\\d*)-\\/?(\\w*)?,?\\[(\".*?\"),(.*)\\]$"].groups()
+            let binaryGroup = mutMessage["^(\\d*)-\\/?(\\w*)?,?(\\d*)?\\[(\".*?\"),(.*)\\]$"].groups()
             
             if binaryGroup != nil {
                 // println(binaryGroup)
-                var event:String!
+                var ackNum:String
-                var mutMessageObject:NSMutableString!
+                var event:String
+                var mutMessageObject:NSMutableString
                 var namespace:String?
+                var numberOfPlaceholders:String
                 let messageType = RegexMutable(binaryGroup[1])
-                let numberOfPlaceholders = messageType["45"] ~= ""
                 
-                // Check if message came from a namespace
+                namespace = binaryGroup[2]
-                if binaryGroup.count == 5 {
+                if binaryGroup[3] != "" {
-                    namespace = binaryGroup[2]
+                    ackNum = binaryGroup[3] as String
-                    event = (RegexMutable(binaryGroup[3])["\""] ~= "") as String
+                } else if self.nsp == nil && binaryGroup[2] != "" {
-                    mutMessageObject = RegexMutable(binaryGroup[4])
+                    ackNum = binaryGroup[2]
+                } else {
+                    ackNum = ""
                 }
                 
+                numberOfPlaceholders = (messageType["45"] ~= "") as String
+                event = (RegexMutable(binaryGroup[4])["\""] ~= "") as String
+                mutMessageObject = RegexMutable(binaryGroup[5])
+                
                 if namespace == "" && self.nsp != nil {
                     self.lastSocketMessage = nil
                     return
@@ -504,8 +602,15 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
                 let placeholdersRemoved = mutMessageObject["(\\{\"_placeholder\":true,\"num\":(\\d*)\\})"]
                     ~= "\"~~$2\""
                 
-                let mes = SocketEvent(event: event, args: placeholdersRemoved,
+                let mes:SocketEvent
-                    placeholders: numberOfPlaceholders.integerValue)
+                if ackNum != "" {
+                    mes = SocketEvent(event: event, args: placeholdersRemoved,
+                        placeholders: numberOfPlaceholders.toInt()!)
+                } else {
+                    mes = SocketEvent(event: event, args: placeholdersRemoved,
+                        placeholders: numberOfPlaceholders.toInt()!, ack: ackNum.toInt())
+                }
+                
                 self.lastSocketMessage = mes
             }
             /**
@@ -524,11 +629,22 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
             
             if let args:AnyObject = parsedArgs {
                 let filledInArgs:AnyObject = self.lastSocketMessage!.fillInPlaceholders(args)
-                self.handleEvent(event, data: filledInArgs)
+                
+                if self.lastSocketMessage!.ack != nil {
+                    self.handleEvent(event, data: filledInArgs, isInternalMessage: false,
+                        wantsAck: self.lastSocketMessage!.ack!, withAckType: 6)
+                } else {
+                    self.handleEvent(event, data: filledInArgs)
+                }
             } else {
                 let filledInArgs:AnyObject = self.lastSocketMessage!.fillInPlaceholders()
-                self.handleEvent(event, data: filledInArgs, multipleItems: true)
+                
-                return
+                if self.lastSocketMessage!.ack != nil {
+                    self.handleEvent(event, data: filledInArgs, isInternalMessage: false,
+                        wantsAck: self.lastSocketMessage!.ack!, withAckType: 6)
+                } else {
+                    self.handleEvent(event, data: filledInArgs)
+                }
             }
         }
     }
@@ -541,8 +657,10 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
     
     // Starts the ping timer
     private func startPingTimer(#interval:Int) {
-        self.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(interval), target: self,
+        dispatch_async(dispatch_get_main_queue()) {
-            selector: Selector("sendPing"), userInfo: nil, repeats: true)
+            self.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(interval), target: self,
+                selector: Selector("sendPing"), userInfo: nil, repeats: true)
+        }
     }
     
     // We lost connection and should attempt to reestablish
@@ -551,8 +669,7 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
             self.connecting = false
             self.reconnects = false
             self.reconnecting = false
-            self.handleEvent("disconnect", data: "Failed to reconnect",
+            self.handleEvent("disconnect", data: "Failed to reconnect", isInternalMessage: true)
-                multipleItems: false, internalMessage: true)
             return
         } else if self.connected {
             self.connecting = false
@@ -561,8 +678,7 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
         }
         
         // println("Trying to reconnect #\(reconnectAttempts - triesLeft)")
-        self.handleEvent("reconnectAttempt", data: triesLeft,
+        self.handleEvent("reconnectAttempt", data: triesLeft, isInternalMessage: true)
-            multipleItems: false, internalMessage: true)
         
         let waitTime = UInt64(self.reconnectWait) * NSEC_PER_SEC
         let time = dispatch_time(DISPATCH_TIME_NOW, Int64(waitTime))
@@ -585,7 +701,13 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
     
     // Called when a message is recieved
     func webSocket(webSocket:SRWebSocket!, didReceiveMessage message:AnyObject?) {
-        dispatch_async(self.handleQueue) {self.parseSocketMessage(message)}
+        dispatch_async(self.handleQueue) {[weak self] in
+            if self == nil {
+                return
+            }
+            
+            self?.parseSocketMessage(message)
+        }
     }
     
     // Called when the socket is opened
@@ -612,11 +734,9 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
         self.connected = false
         self.connecting = false
         if self.closed || !self.reconnects {
-            self.handleEvent("disconnect", data: reason,
+            self.handleEvent("disconnect", data: reason, isInternalMessage: true)
-                multipleItems: false, internalMessage: true)
         } else {
-            self.handleEvent("reconnect", data: reason,
+            self.handleEvent("reconnect", data: reason, isInternalMessage: true)
-                multipleItems: false, internalMessage: true)
             self.tryReconnect(triesLeft: self.reconnectAttempts)
             
         }
@@ -627,14 +747,11 @@ class SocketIOClient: NSObject, SRWebSocketDelegate {
         self.pingTimer?.invalidate()
         self.connected = false
         self.connecting = false
-        self.handleEvent("error", data: error.localizedDescription,
+        self.handleEvent("error", data: error.localizedDescription, isInternalMessage: true)
-            multipleItems: false, internalMessage: true)
         if self.closed || !self.reconnects {
-            self.handleEvent("disconnect", data: error.localizedDescription,
+            self.handleEvent("disconnect", data: error.localizedDescription, isInternalMessage: true)
-                multipleItems: false, internalMessage: true)
         } else if !self.reconnecting {
-            self.handleEvent("reconnect", data: error.localizedDescription,
+            self.handleEvent("reconnect", data: error.localizedDescription, isInternalMessage: true)
-                multipleItems: false, internalMessage: true)
             self.tryReconnect(triesLeft: self.reconnectAttempts)
         }
     }