work on socketio/socket.io-client-swift#70

SocketIOClientSwift/SocketEngine.swift

@@ -95,9 +95,9 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
     }
     
     public init(client:SocketEngineClient, sessionDelegate:NSURLSessionDelegate?) {
-            self.client = client
+        self.client = client
-            self.session = NSURLSession(configuration: NSURLSessionConfiguration.ephemeralSessionConfiguration(),
+        self.session = NSURLSession(configuration: NSURLSessionConfiguration.ephemeralSessionConfiguration(),
-                delegate: sessionDelegate, delegateQueue: self.workQueue)
+            delegate: sessionDelegate, delegateQueue: self.workQueue)
     }
     
     public convenience init(client:SocketEngineClient, opts:NSDictionary?) {
@@ -122,7 +122,7 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
         self.write("", withType: PacketType.CLOSE, withData: nil)
         self.ws?.disconnect()
         self.stopPolling()
-
+        
         if fast || self.polling {
             self.client?.engineDidClose("Disconnect")
         }
@@ -240,33 +240,32 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
         SocketLogger.log("Doing polling request", client: self)
         
         self.session.dataTaskWithRequest(req) {[weak self] data, res, err in
-            if self == nil {
+            if let this = self {
-                return
+                if err != nil {
-            } else if err != nil {
+                    if this.polling {
-                if self!.polling {
+                        this.handlePollingFailed(err.localizedDescription)
-                    self?.handlePollingFailed(err.localizedDescription)
+                    } else {
-                } else {
+                        NSLog(err.localizedDescription)
-                    NSLog(err.localizedDescription)
+                    }
+                    return
                 }
                 
-                return
+                SocketLogger.log("Got polling response", client: this)
-            }
+                
-            
+                if let str = NSString(data: data, encoding: NSUTF8StringEncoding) as? String {
-            SocketLogger.log("Got polling response", client: self!)
+                    dispatch_async(this.parseQueue) {[weak this] in
-            
+                        this?.parsePollingMessage(str)
-            if let str = NSString(data: data, encoding: NSUTF8StringEncoding) as? String {
+                    }
-                dispatch_async(self!.parseQueue) {[weak self] in
+                }
-                    self?.parsePollingMessage(str)
+                
+                this.waitingForPoll = false
+                
+                if this.fastUpgrade {
+                    this.doFastUpgrade()
+                    return
+                } else if !this.closed && this.polling {
+                    this.doPoll()
                 }
-            }
-            
-            self?.waitingForPoll = false
-            
-            if self!.fastUpgrade {
-                self?.doFastUpgrade()
-                return
-            } else if !self!.closed && self!.polling {
-                self?.doPoll()
             }}.resume()
     }
     
@@ -274,18 +273,16 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
         SocketLogger.log("Flushing probe wait", client: self)
         
         dispatch_async(self.emitQueue) {[weak self] in
-            if self == nil {
+            if let this = self {
-                return
+                for waiter in this.probeWait {
-            }
+                    this.write(waiter.msg, withType: waiter.type, withData: waiter.data)
-            
+                }
-            for waiter in self!.probeWait {
+                
-                self?.write(waiter.msg, withType: waiter.type, withData: waiter.data)
+                this.probeWait.removeAll(keepCapacity: false)
-            }
+                
-            
+                if this.postWait.count != 0 {
-            self?.probeWait.removeAll(keepCapacity: false)
+                    this.flushWaitingForPostToWebSocket()
-            
+                }
-            if self?.postWait.count != 0 {
-                self?.flushWaitingForPostToWebSocket()
             }
         }
     }
@@ -329,21 +326,22 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
         SocketLogger.log("POSTing: \(postStr)", client: self)
         
         self.session.dataTaskWithRequest(req) {[weak self] data, res, err in
-            if self == nil {
+            if let this = self {
-                return
+                if err != nil && this.polling {
-            } else if err != nil && self!.polling {
+                    this.handlePollingFailed(err.localizedDescription)
-                self?.handlePollingFailed(err.localizedDescription)
+                    return
-                return
+                } else if err != nil {
-            } else if err != nil {
+                    NSLog(err.localizedDescription)
-                NSLog(err.localizedDescription)
+                    return
-                return
+                }
-            }
+                
-            
+                this.waitingForPost = false
-            self?.waitingForPost = false
+                
-            dispatch_async(self!.emitQueue) {[weak self] in
+                dispatch_async(this.emitQueue) {[weak this] in
-                if !self!.fastUpgrade {
+                    if !(this?.fastUpgrade ?? true) {
-                    self?.flushWaitingForPost()
+                        this?.flushWaitingForPost()
-                    self?.doPoll()
+                        this?.doPoll()
+                    }
                 }
             }}.resume()
     }
@@ -468,12 +466,10 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
     }
     
     private func parseEngineData(data:NSData) {
-        if self.client == nil {
+        if let client = self.client {
-            return
+            dispatch_async(client.handleQueue) {[weak self] in
-        }
+                self?.client?.parseBinaryData(data.subdataWithRange(NSMakeRange(1, data.length - 1)))
-        
+            }
-        dispatch_async(self.client!.handleQueue) {[weak self] in
-            self?.client?.parseBinaryData(data.subdataWithRange(NSMakeRange(1, data.length - 1)))
         }
     }
     
@@ -490,12 +486,10 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
             // Remove message type
             message.removeAtIndex(message.startIndex)
             
-            if self.client == nil {
+            if let client = self.client {
-                return
+                dispatch_async(client.handleQueue) {[weak self] in
-            }
+                    self?.client?.parseSocketMessage(message)
-            
+                }
-            dispatch_async(self.client!.handleQueue) {[weak self] in
-                self?.client?.parseSocketMessage(message)
             }
         } else if type == PacketType.NOOP {
             self.doPoll()
@@ -555,11 +549,8 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
                 end: advance(message.startIndex, 2)))
             
             if let data = NSData(base64EncodedString: message,
-                options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters)
+                options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters), client = self.client {
-                where self.client != nil {
+                    dispatch_async(client.handleQueue) {[weak self] in
-                    // println("sending \(data)")
-                    
-                    dispatch_async(self.client!.handleQueue) {[weak self] in
                         self?.client?.parseBinaryData(data)
                     }
             }
@@ -635,13 +626,11 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
         
         self.pingTimer?.invalidate()
         dispatch_async(dispatch_get_main_queue()) {[weak self] in
-            if self == nil {
+            if let this = self {
-                return
+                this.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(this.pingInterval!),
+                    target: this,
+                    selector: Selector("sendPing"), userInfo: nil, repeats: true)
             }
-            
-            self?.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(self!.pingInterval!),
-                target: self!,
-                selector: Selector("sendPing"), userInfo: nil, repeats: true)
         }
     }
     
@@ -665,16 +654,14 @@ public final class SocketEngine: NSObject, WebSocketDelegate, SocketLogClient {
     */
     public func write(msg:String, withType type:PacketType, withData data:ContiguousArray<NSData>?) {
         dispatch_async(self.emitQueue) {[weak self] in
-            if self == nil || !self!.connected {
+            if let this = self where this.connected {
-                return
+                if this.websocket {
-            }
+                    SocketLogger.log("Writing ws: \(msg):\(data)", client: this)
-            
+                    this.sendWebSocketMessage(msg, withType: type, datas: data)
-            if self!.websocket {
+                } else {
-                SocketLogger.log("Writing ws: \(msg):\(data)", client: self!)
+                    SocketLogger.log("Writing poll: \(msg):\(data)", client: this)
-                self?.sendWebSocketMessage(msg, withType: type, datas: data)
+                    this.sendPollMessage(msg, withType: type, datas: data)
-            } else {
+                }
-                SocketLogger.log("Writing poll: \(msg):\(data)", client: self!)
-                self?.sendPollMessage(msg, withType: type, datas: data)
             }
         }
     }