425 lines
14 KiB
Swift
425 lines
14 KiB
Swift
//
|
|
// SocketIOClient.swift
|
|
// Socket.IO-Swift
|
|
//
|
|
// Created by Erik Little on 11/23/14.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
private class EventHandler: NSObject {
|
|
let event:String!
|
|
let callback:((data:Any?) -> Void)!
|
|
|
|
init(event:String, callback:((data:Any?) -> Void)?) {
|
|
self.event = event
|
|
self.callback = callback
|
|
}
|
|
|
|
func executeCallback(args:Any?) {
|
|
if (args != nil) {
|
|
callback(data: args!)
|
|
} else {
|
|
callback(data: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct Event {
|
|
var event:String!
|
|
var args:Any!
|
|
var placeholders:Int!
|
|
var currentPlace = 0
|
|
|
|
init(event:String, args:Any?, placeholders:Int = 0) {
|
|
self.event = event
|
|
self.args = args?
|
|
self.placeholders = placeholders
|
|
}
|
|
|
|
func createMessage() -> String {
|
|
var array = "42["
|
|
array += "\"" + event + "\""
|
|
if (args? != nil) {
|
|
if (args is NSDictionary) {
|
|
array += ","
|
|
var jsonSendError:NSError?
|
|
var jsonSend = NSJSONSerialization.dataWithJSONObject(args as NSDictionary,
|
|
options: NSJSONWritingOptions(0), error: &jsonSendError)
|
|
var jsonString = NSString(data: jsonSend!, encoding: NSUTF8StringEncoding)
|
|
return array + jsonString! + "]"
|
|
} else {
|
|
array += ",\"\(args!)\""
|
|
return array + "]"
|
|
}
|
|
} else {
|
|
return array + "]"
|
|
}
|
|
}
|
|
|
|
func createBinaryMessage() -> String {
|
|
var array = "45\(self.placeholders)-["
|
|
array += "\"" + event + "\""
|
|
if (args? != nil) {
|
|
if (args is NSDictionary) {
|
|
array += ","
|
|
var jsonSendError:NSError?
|
|
var jsonSend = NSJSONSerialization.dataWithJSONObject(args as NSDictionary,
|
|
options: NSJSONWritingOptions(0), error: &jsonSendError)
|
|
var jsonString = NSString(data: jsonSend!, encoding: NSUTF8StringEncoding)
|
|
return array + jsonString! + "]"
|
|
} else {
|
|
array += ",\"\(args!)\""
|
|
return array + "]"
|
|
}
|
|
} else {
|
|
return array + "]"
|
|
}
|
|
}
|
|
|
|
mutating func fillInPlaceHolder(data:NSData) -> Bool {
|
|
func checkDoEvent() -> Bool {
|
|
if (self.placeholders == self.currentPlace) {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
if (checkDoEvent()) {
|
|
return true
|
|
}
|
|
|
|
if let stringArgs = args as? String {
|
|
let mutStringArgs = RegexMutable(stringArgs)
|
|
let base64 = data.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.allZeros)
|
|
let placeHolder = "~~" + String(self.currentPlace)
|
|
self.args = mutStringArgs[placeHolder] ~= "\"" + base64 + "\""
|
|
self.currentPlace++
|
|
return checkDoEvent()
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
class SocketIOClient: NSObject, SRWebSocketDelegate {
|
|
let socketURL:String!
|
|
var connected = false
|
|
var connecting = false
|
|
private var handlers = [EventHandler]()
|
|
var io:SRWebSocket?
|
|
var pingTimer:NSTimer!
|
|
private var lastSocketMessage:Event?
|
|
var secure = false
|
|
|
|
init(socketURL:String, secure:Bool = false) {
|
|
var mutURL = RegexMutable(socketURL)
|
|
mutURL = mutURL["http://"] ~= ""
|
|
mutURL = mutURL["https://"] ~= ""
|
|
self.socketURL = mutURL
|
|
self.secure = secure
|
|
}
|
|
|
|
// Closes the socket
|
|
func close() {
|
|
self.pingTimer?.invalidate()
|
|
self.connecting = false
|
|
self.connected = false
|
|
self.io?.close()
|
|
}
|
|
|
|
// Connects to the server
|
|
func connect() {
|
|
self.connecting = true
|
|
var endpoint:String!
|
|
if (self.secure) {
|
|
endpoint = "wss://\(self.socketURL)/socket.io/?EIO=2&transport=websocket"
|
|
} else {
|
|
endpoint = "ws://\(self.socketURL)/socket.io/?EIO=2&transport=websocket"
|
|
}
|
|
self.io = SRWebSocket(URL: NSURL(string: endpoint))
|
|
self.io?.delegate = self
|
|
self.io?.open()
|
|
}
|
|
|
|
// Creates a binary message, ready for sending
|
|
private func createBinaryDataForSend(data:NSData) -> NSData {
|
|
var byteArray = [UInt8](count: 1, repeatedValue: 0x0)
|
|
byteArray[0] = 4
|
|
var mutData = NSMutableData(bytes: &byteArray, length: 1)
|
|
mutData.appendData(data)
|
|
return mutData
|
|
}
|
|
|
|
// Sends a message
|
|
func emit(event:String, args:Any? = nil) {
|
|
if (!self.connected) {
|
|
return
|
|
}
|
|
var frame:Event!
|
|
var str:String!
|
|
|
|
if let dict = args as? NSDictionary {
|
|
// Check for binary data
|
|
let (newDict, hadBinary, binaryDatas) = self.parseNSDictionary(dict: dict)
|
|
if (hadBinary) {
|
|
frame = Event(event: event, args: newDict, placeholders: binaryDatas!.count)
|
|
str = frame.createBinaryMessage()
|
|
self.io?.send(str)
|
|
for data in binaryDatas! {
|
|
let sendData = self.createBinaryDataForSend(data)
|
|
self.io?.send(sendData)
|
|
}
|
|
return
|
|
}
|
|
} else if let binaryData = args as? NSData {
|
|
// args is just binary
|
|
frame = Event(event: event, args: ["_placeholder": true, "num": 0], placeholders: 1)
|
|
str = frame.createBinaryMessage()
|
|
self.io?.send(str)
|
|
let sendData = self.createBinaryDataForSend(binaryData)
|
|
self.io?.send(sendData)
|
|
return
|
|
}
|
|
|
|
frame = Event(event: event, args: args)
|
|
str = frame.createMessage()
|
|
|
|
// println("Sending: \(str)")
|
|
self.io?.send(str)
|
|
}
|
|
|
|
// Handles events
|
|
func handleEvent(#event:String, var data:Any?) {
|
|
// println("Should do event: \(event) with data: \(data)")
|
|
data = parseData(data)
|
|
for handler in self.handlers {
|
|
if (handler.event == event) {
|
|
if (data == nil) {
|
|
handler.executeCallback(nil)
|
|
continue
|
|
}
|
|
handler.executeCallback(data)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Adds handlers to the socket
|
|
func on(name:String, callback:((data:Any?) -> Void)?) {
|
|
let handler = EventHandler(event: name, callback: callback)
|
|
self.handlers.append(handler)
|
|
}
|
|
|
|
// Opens the connection to the socket
|
|
func open() {
|
|
self.connect()
|
|
}
|
|
|
|
// temporary until I redo how messages are parsed
|
|
private func parseData(data:Any?) -> Any? {
|
|
if (data == nil) {
|
|
return nil
|
|
}
|
|
|
|
if let json = self.toJSON(data) {
|
|
return json
|
|
}
|
|
|
|
let dataAsString = data as String
|
|
if (dataAsString == "true") {
|
|
return true
|
|
} else if (dataAsString == "false") {
|
|
return false
|
|
} else if (dataAsString.hasPrefix("[") && dataAsString.hasSuffix("]")) {
|
|
var trimArray = Array(dataAsString)
|
|
trimArray.removeAtIndex(0)
|
|
trimArray.removeAtIndex(trimArray.count - 1)
|
|
var ret = String(trimArray).componentsSeparatedByString(",")
|
|
var returnArray = [Any]()
|
|
for item in ret {
|
|
returnArray.append(item)
|
|
}
|
|
return returnArray
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
// Parses a NSDictionary, looking for NSData objects
|
|
private func parseNSDictionary(#dict:NSDictionary) -> (NSDictionary, Bool, [NSData]?) {
|
|
var returnDict = NSMutableDictionary()
|
|
var placeholder = 0
|
|
var containedData = false
|
|
var returnDatas = [NSData]()
|
|
for (key, value) in dict {
|
|
if let binaryData = value as? NSData {
|
|
containedData = true
|
|
returnDatas.append(binaryData)
|
|
returnDict[key as String] = ["_placeholder": true, "num": placeholder]
|
|
placeholder++
|
|
} else {
|
|
returnDict[key as String] = value
|
|
}
|
|
}
|
|
if (containedData) {
|
|
return (returnDict, true, returnDatas)
|
|
} else {
|
|
return (returnDict, false, nil)
|
|
}
|
|
}
|
|
|
|
// Parses messages recieved
|
|
private func parseSocketMessage(#message:AnyObject?) {
|
|
if (message == nil) {
|
|
return
|
|
}
|
|
// println(message!)
|
|
|
|
if let stringMessage = message as? String {
|
|
/**
|
|
Begin check for socket info frame
|
|
**/
|
|
var mutMessage = RegexMutable(stringMessage)
|
|
var setup:String!
|
|
let messageData = mutMessage["(\\d*)(\\{.*\\})?"].groups()
|
|
if (messageData != nil && messageData[1] == "0") {
|
|
setup = messageData[2]
|
|
let data = setup.dataUsingEncoding(NSUTF8StringEncoding)!
|
|
var jsonError:NSError?
|
|
if let json:AnyObject? = NSJSONSerialization.JSONObjectWithData(data,
|
|
options: nil, error: &jsonError) {
|
|
self.startPingTimer(interval: (json!["pingInterval"] as Int) / 1000)
|
|
return
|
|
}
|
|
}
|
|
/**
|
|
End check for socket info frame
|
|
**/
|
|
|
|
/**
|
|
Begin check for message
|
|
**/
|
|
let messageGroups = mutMessage["(\\d*)(\\[.*\\])?"].groups()
|
|
if (messageGroups.count == 3 && messageGroups[1] == "42") {
|
|
let messagePart = messageGroups[2]
|
|
let messageInternals = RegexMutable(messagePart)["\\[\"(.*?)\",(.*?)?\\]$"].groups()
|
|
if (messageInternals != nil && messageInternals.count > 2) {
|
|
let event = messageInternals[1]
|
|
var data:String?
|
|
if (messageInternals[2] == "") {
|
|
data = nil
|
|
} else {
|
|
data = messageInternals[2]
|
|
|
|
}
|
|
|
|
self.handleEvent(event: event, data: data)
|
|
return
|
|
}
|
|
}
|
|
/**
|
|
End Check for message
|
|
**/
|
|
|
|
// Check for message with binary placeholders
|
|
self.parseBinaryMessage(message: message!)
|
|
}
|
|
|
|
// Message is binary
|
|
if let binary = message as? NSData {
|
|
self.parseBinaryData(binary)
|
|
}
|
|
}
|
|
|
|
// Tries to parse a message that contains binary
|
|
func parseBinaryMessage(#message:AnyObject) {
|
|
if let stringMessage = message as? String {
|
|
var mutMessage = RegexMutable(stringMessage)
|
|
/**
|
|
Begin check for binary placeholder
|
|
**/
|
|
let binaryGroup = mutMessage["(\\d*)-\\[\"(.*)\",(\\{.*\\})\\]$"].groups()
|
|
// println(binaryGroup)
|
|
if (binaryGroup != nil) {
|
|
let messageType = RegexMutable(binaryGroup[1])
|
|
let numberOfPlaceholders = messageType["45"] ~= ""
|
|
let event = binaryGroup[2]
|
|
let mutMessageObject = RegexMutable(binaryGroup[3])
|
|
let placeholdersRemoved = mutMessageObject["(\\{\"_placeholder\":true,\"num\":(\\d*)\\})"] ~= "~~$2"
|
|
let mes = Event(event: event, args: placeholdersRemoved,
|
|
placeholders: numberOfPlaceholders.integerValue)
|
|
self.lastSocketMessage = mes
|
|
return
|
|
}
|
|
/**
|
|
End check for binary placeholder
|
|
**/
|
|
}
|
|
}
|
|
|
|
// Handles binary data
|
|
func parseBinaryData(data:NSData) {
|
|
if (self.lastSocketMessage == nil) {
|
|
return
|
|
}
|
|
|
|
let shouldExecute = self.lastSocketMessage?.fillInPlaceHolder(data)
|
|
var event = self.lastSocketMessage!.event
|
|
var args = self.lastSocketMessage!.args
|
|
// println(args)
|
|
if (shouldExecute != nil && shouldExecute!) {
|
|
self.handleEvent(event: event, data: args)
|
|
}
|
|
}
|
|
|
|
// Sends ping
|
|
func sendPing() {
|
|
if (!self.connected) {
|
|
return
|
|
}
|
|
self.io?.send("2")
|
|
}
|
|
|
|
// Starts the ping timer
|
|
private func startPingTimer(#interval:Int) {
|
|
self.pingTimer = NSTimer.scheduledTimerWithTimeInterval(NSTimeInterval(interval), target: self,
|
|
selector: Selector("sendPing"), userInfo: nil, repeats: true)
|
|
}
|
|
|
|
// Helper method
|
|
func toJSON(data:Any?) -> NSDictionary? {
|
|
if (data == nil || data is Bool || data is Int) {
|
|
return nil
|
|
}
|
|
var err:NSError?
|
|
var stringData = data as String
|
|
var JSONData = stringData.dataUsingEncoding(NSUTF8StringEncoding)
|
|
var json:AnyObject? = NSJSONSerialization.JSONObjectWithData(JSONData!, options: NSJSONReadingOptions.allZeros, error: &err)
|
|
if (err != nil || json == nil) {
|
|
// println(err?.localizedDescription)
|
|
return nil
|
|
}
|
|
return json as? NSDictionary
|
|
}
|
|
|
|
// Called when a message is recieved
|
|
func webSocket(webSocket: SRWebSocket!, didReceiveMessage message:AnyObject?) {
|
|
// println(message)
|
|
self.parseSocketMessage(message: message)
|
|
}
|
|
|
|
// Called when the socket is opened
|
|
func webSocketDidOpen(webSocket: SRWebSocket!) {
|
|
self.connecting = false
|
|
self.connected = true
|
|
self.handleEvent(event: "connect", data: nil)
|
|
}
|
|
|
|
// Called when the socket is closed
|
|
func webSocket(webSocket: SRWebSocket!, didCloseWithCode code: Int, reason: String!, wasClean: Bool) {
|
|
self.pingTimer?.invalidate()
|
|
self.connected = false
|
|
self.connecting = false
|
|
self.handleEvent(event: "disconnect", data: reason)
|
|
}
|
|
} |