Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5939 from dumganhar/merge5923 

Merge PR #5923: implement fireEventToScript method to integrate JSB event handling with the original native code
This commit is contained in:
James Chen 2014-03-24 18:08:02 +08:00
parent 666f2f34e9 ae2027ea53
commit ec4b1ee485
3 changed files with 389 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

561
cocos/network/SocketIO.cpp
View File

@ -43,48 +43,48 @@ namespace network {
/** /**
* @brief The implementation of the socket.io connection * @brief The implementation of the socket.io connection
* Clients/endpoints may share the same impl to accomplish multiplexing on the same websocket * Clients/endpoints may share the same impl to accomplish multiplexing on the same websocket
*/ */
class SIOClientImpl : class SIOClientImpl :
public cocos2d::Ref, public cocos2d::Ref,
public WebSocket::Delegate public WebSocket::Delegate
{ {
private: private:
int _port, _heartbeat, _timeout; int _port, _heartbeat, _timeout;
std::string _host, _sid, _uri; std::string _host, _sid, _uri;
bool _connected; bool _connected;
WebSocket *_ws; WebSocket *_ws;
Map<std::string, SIOClient*> _clients; Map<std::string, SIOClient*> _clients;
public: public:
SIOClientImpl(const std::string& host, int port); SIOClientImpl(const std::string& host, int port);
virtual ~SIOClientImpl(void); virtual ~SIOClientImpl(void);
static SIOClientImpl* create(const std::string& host, int port); static SIOClientImpl* create(const std::string& host, int port);
virtual void onOpen(WebSocket* ws); virtual void onOpen(WebSocket* ws);
virtual void onMessage(WebSocket* ws, const WebSocket::Data& data); virtual void onMessage(WebSocket* ws, const WebSocket::Data& data);
virtual void onClose(WebSocket* ws); virtual void onClose(WebSocket* ws);
virtual void onError(WebSocket* ws, const WebSocket::ErrorCode& error); virtual void onError(WebSocket* ws, const WebSocket::ErrorCode& error);
void connect(); void connect();
void disconnect(); void disconnect();
bool init(); bool init();
void handshake(); void handshake();
void handshakeResponse(HttpClient *sender, HttpResponse *response); void handshakeResponse(HttpClient *sender, HttpResponse *response);
void openSocket(); void openSocket();
void heartbeat(float dt); void heartbeat(float dt);
SIOClient* getClient(const std::string& endpoint); SIOClient* getClient(const std::string& endpoint);
void addClient(const std::string& endpoint, SIOClient* client); void addClient(const std::string& endpoint, SIOClient* client);
void connectToEndpoint(const std::string& endpoint); void connectToEndpoint(const std::string& endpoint);
void disconnectFromEndpoint(const std::string& endpoint); void disconnectFromEndpoint(const std::string& endpoint);
void send(std::string endpoint, std::string s); void send(std::string endpoint, std::string s);
void emit(std::string endpoint, std::string eventname, std::string args); void emit(std::string endpoint, std::string eventname, std::string args);
}; };
@ -94,63 +94,63 @@ public:
//begin SIOClientImpl methods //begin SIOClientImpl methods
SIOClientImpl::SIOClientImpl(const std::string& host, int port) : SIOClientImpl::SIOClientImpl(const std::string& host, int port) :
_port(port), _port(port),
_host(host), _host(host),
_connected(false) _connected(false)
{ {
std::stringstream s; std::stringstream s;
s << host << ":" << port; s << host << ":" << port;
_uri = s.str(); _uri = s.str();
_ws = nullptr; _ws = nullptr;
} }
SIOClientImpl::~SIOClientImpl() SIOClientImpl::~SIOClientImpl()
{ {
if (_connected) if (_connected)
disconnect(); disconnect();
CC_SAFE_DELETE(_ws); CC_SAFE_DELETE(_ws);
} }
void SIOClientImpl::handshake() void SIOClientImpl::handshake()
{ {
log("SIOClientImpl::handshake() called"); log("SIOClientImpl::handshake() called");
std::stringstream pre; std::stringstream pre;
pre << "http://" << _uri << "/socket.io/1"; pre << "http://" << _uri << "/socket.io/1";
HttpRequest* request = new HttpRequest(); HttpRequest* request = new HttpRequest();
request->setUrl(pre.str().c_str()); request->setUrl(pre.str().c_str());
request->setRequestType(HttpRequest::Type::GET); request->setRequestType(HttpRequest::Type::GET);
request->setResponseCallback(this, httpresponse_selector(SIOClientImpl::handshakeResponse)); request->setResponseCallback(this, httpresponse_selector(SIOClientImpl::handshakeResponse));
request->setTag("handshake"); request->setTag("handshake");
log("SIOClientImpl::handshake() waiting"); log("SIOClientImpl::handshake() waiting");
HttpClient::getInstance()->send(request); HttpClient::getInstance()->send(request);
request->release(); request->release();
return; return;
} }
void SIOClientImpl::handshakeResponse(HttpClient *sender, HttpResponse *response) void SIOClientImpl::handshakeResponse(HttpClient *sender, HttpResponse *response)
{ {
log("SIOClientImpl::handshakeResponse() called"); log("SIOClientImpl::handshakeResponse() called");
if (0 != strlen(response->getHttpRequest()->getTag())) if (0 != strlen(response->getHttpRequest()->getTag()))
{ {
log("%s completed", response->getHttpRequest()->getTag()); log("%s completed", response->getHttpRequest()->getTag());
} }
long statusCode = response->getResponseCode(); long statusCode = response->getResponseCode();
char statusString[64] = {}; char statusString[64] = {};
sprintf(statusString, "HTTP Status Code: %ld, tag = %s", statusCode, response->getHttpRequest()->getTag()); sprintf(statusString, "HTTP Status Code: %ld, tag = %s", statusCode, response->getHttpRequest()->getTag());
log("response code: %ld", statusCode); log("response code: %ld", statusCode);
if (!response->isSucceed()) if (!response->isSucceed())
{ {
log("SIOClientImpl::handshake() failed"); log("SIOClientImpl::handshake() failed");
log("error buffer: %s", response->getErrorBuffer()); log("error buffer: %s", response->getErrorBuffer());
@ -163,302 +163,302 @@ void SIOClientImpl::handshakeResponse(HttpClient *sender, HttpResponse *response
return; return;
} }
log("SIOClientImpl::handshake() succeeded"); log("SIOClientImpl::handshake() succeeded");
std::vector<char> *buffer = response->getResponseData(); std::vector<char> *buffer = response->getResponseData();
std::stringstream s; std::stringstream s;
for (unsigned int i = 0; i < buffer->size(); i++) for (unsigned int i = 0; i < buffer->size(); i++)
{ {
s << (*buffer)[i]; s << (*buffer)[i];
} }
log("SIOClientImpl::handshake() dump data: %s", s.str().c_str()); log("SIOClientImpl::handshake() dump data: %s", s.str().c_str());
std::string res = s.str(); std::string res = s.str();
std::string sid; std::string sid;
size_t pos = 0; size_t pos = 0;
int heartbeat = 0, timeout = 0; int heartbeat = 0, timeout = 0;
pos = res.find(":"); pos = res.find(":");
if(pos != std::string::npos) if(pos != std::string::npos)
{ {
sid = res.substr(0, pos); sid = res.substr(0, pos);
res.erase(0, pos+1); res.erase(0, pos+1);
} }
pos = res.find(":"); pos = res.find(":");
if(pos != std::string::npos) if(pos != std::string::npos)
{ {
heartbeat = atoi(res.substr(pos+1, res.size()).c_str()); heartbeat = atoi(res.substr(pos+1, res.size()).c_str());
} }
pos = res.find(":"); pos = res.find(":");
if(pos != std::string::npos) if(pos != std::string::npos)
{ {
timeout = atoi(res.substr(pos+1, res.size()).c_str()); timeout = atoi(res.substr(pos+1, res.size()).c_str());
} }
_sid = sid; _sid = sid;
_heartbeat = heartbeat; _heartbeat = heartbeat;
_timeout = timeout; _timeout = timeout;
openSocket(); openSocket();
return; return;
} }
void SIOClientImpl::openSocket() void SIOClientImpl::openSocket()
{ {
log("SIOClientImpl::openSocket() called"); log("SIOClientImpl::openSocket() called");
std::stringstream s; std::stringstream s;
s << _uri << "/socket.io/1/websocket/" << _sid; s << _uri << "/socket.io/1/websocket/" << _sid;
_ws = new WebSocket(); _ws = new WebSocket();
if (!_ws->init(*this, s.str())) if (!_ws->init(*this, s.str()))
{ {
CC_SAFE_DELETE(_ws); CC_SAFE_DELETE(_ws);
} }
return; return;
} }
bool SIOClientImpl::init() bool SIOClientImpl::init()
{ {
log("SIOClientImpl::init() successful"); log("SIOClientImpl::init() successful");
return true; return true;
} }
void SIOClientImpl::connect() void SIOClientImpl::connect()
{ {
this->handshake(); this->handshake();
} }
void SIOClientImpl::disconnect() void SIOClientImpl::disconnect()
{ {
if(_ws->getReadyState() == WebSocket::State::OPEN) if(_ws->getReadyState() == WebSocket::State::OPEN)
{ {
std::string s = "0::"; std::string s = "0::";
_ws->send(s); _ws->send(s);
log("Disconnect sent"); log("Disconnect sent");
_ws->close(); _ws->close();
} }
Director::getInstance()->getScheduler()->unscheduleAllForTarget(this); Director::getInstance()->getScheduler()->unscheduleAllForTarget(this);
_connected = false; _connected = false;
SocketIO::getInstance()->removeSocket(_uri); SocketIO::getInstance()->removeSocket(_uri);
} }
SIOClientImpl* SIOClientImpl::create(const std::string& host, int port) SIOClientImpl* SIOClientImpl::create(const std::string& host, int port)
{ {
SIOClientImpl *s = new SIOClientImpl(host, port); SIOClientImpl *s = new SIOClientImpl(host, port);
if (s && s->init()) if (s && s->init())
{ {
return s; return s;
} }
return nullptr; return nullptr;
} }
SIOClient* SIOClientImpl::getClient(const std::string& endpoint) SIOClient* SIOClientImpl::getClient(const std::string& endpoint)
{ {
return _clients.at(endpoint); return _clients.at(endpoint);
} }
void SIOClientImpl::addClient(const std::string& endpoint, SIOClient* client) void SIOClientImpl::addClient(const std::string& endpoint, SIOClient* client)
{ {
_clients.insert(endpoint, client); _clients.insert(endpoint, client);
} }
void SIOClientImpl::connectToEndpoint(const std::string& endpoint) void SIOClientImpl::connectToEndpoint(const std::string& endpoint)
{ {
std::string path = endpoint == "/" ? "" : endpoint; std::string path = endpoint == "/" ? "" : endpoint;
std::string s = "1::" + path; std::string s = "1::" + path;
_ws->send(s); _ws->send(s);
} }
void SIOClientImpl::disconnectFromEndpoint(const std::string& endpoint) void SIOClientImpl::disconnectFromEndpoint(const std::string& endpoint)
{ {
_clients.erase(endpoint); _clients.erase(endpoint);
if (_clients.empty() || endpoint == "/") if (_clients.empty() || endpoint == "/")
{ {
log("SIOClientImpl::disconnectFromEndpoint out of endpoints, checking for disconnect"); log("SIOClientImpl::disconnectFromEndpoint out of endpoints, checking for disconnect");
if(_connected) if(_connected)
this->disconnect(); this->disconnect();
} }
else else
{ {
std::string path = endpoint == "/" ? "" : endpoint; std::string path = endpoint == "/" ? "" : endpoint;
std::string s = "0::" + path; std::string s = "0::" + path;
_ws->send(s); _ws->send(s);
} }
} }
void SIOClientImpl::heartbeat(float dt) void SIOClientImpl::heartbeat(float dt)
{ {
std::string s = "2::"; std::string s = "2::";
_ws->send(s); _ws->send(s);
log("Heartbeat sent"); log("Heartbeat sent");
} }
void SIOClientImpl::send(std::string endpoint, std::string s) void SIOClientImpl::send(std::string endpoint, std::string s)
{ {
std::stringstream pre; std::stringstream pre;
std::string path = endpoint == "/" ? "" : endpoint; std::string path = endpoint == "/" ? "" : endpoint;
pre << "3::" << path << ":" << s; pre << "3::" << path << ":" << s;
std::string msg = pre.str(); std::string msg = pre.str();
log("sending message: %s", msg.c_str()); log("sending message: %s", msg.c_str());
_ws->send(msg); _ws->send(msg);
} }
void SIOClientImpl::emit(std::string endpoint, std::string eventname, std::string args) void SIOClientImpl::emit(std::string endpoint, std::string eventname, std::string args)
{ {
std::stringstream pre; std::stringstream pre;
std::string path = endpoint == "/" ? "" : endpoint; std::string path = endpoint == "/" ? "" : endpoint;
pre << "5::" << path << ":{\"name\":\"" << eventname << "\",\"args\":" << args << "}"; pre << "5::" << path << ":{\"name\":\"" << eventname << "\",\"args\":" << args << "}";
std::string msg = pre.str(); std::string msg = pre.str();
log("emitting event with data: %s", msg.c_str()); log("emitting event with data: %s", msg.c_str());
_ws->send(msg); _ws->send(msg);
} }
void SIOClientImpl::onOpen(WebSocket* ws) void SIOClientImpl::onOpen(WebSocket* ws)
{ {
_connected = true; _connected = true;
SocketIO::getInstance()->addSocket(_uri, this); SocketIO::getInstance()->addSocket(_uri, this);
for (auto iter = _clients.begin(); iter != _clients.end(); ++iter) for (auto iter = _clients.begin(); iter != _clients.end(); ++iter)
{ {
iter->second->onOpen(); iter->second->onOpen();
} }
Director::getInstance()->getScheduler()->schedule(schedule_selector(SIOClientImpl::heartbeat), this, (_heartbeat * .9f), false); Director::getInstance()->getScheduler()->schedule(schedule_selector(SIOClientImpl::heartbeat), this, (_heartbeat * .9f), false);
log("SIOClientImpl::onOpen socket connected!"); log("SIOClientImpl::onOpen socket connected!");
} }
void SIOClientImpl::onMessage(WebSocket* ws, const WebSocket::Data& data) void SIOClientImpl::onMessage(WebSocket* ws, const WebSocket::Data& data)
{ {
log("SIOClientImpl::onMessage received: %s", data.bytes); log("SIOClientImpl::onMessage received: %s", data.bytes);
int control = atoi(&data.bytes[0]); int control = atoi(&data.bytes[0]);
std::string payload, msgid, endpoint, s_data, eventname; std::string payload, msgid, endpoint, s_data, eventname;
payload = data.bytes; payload = data.bytes;
size_t pos, pos2; size_t pos, pos2;
pos = payload.find(":"); pos = payload.find(":");
if(pos != std::string::npos ) { if(pos != std::string::npos ) {
payload.erase(0, pos+1); payload.erase(0, pos+1);
} }
pos = payload.find(":"); pos = payload.find(":");
if(pos != std::string::npos ) { if(pos != std::string::npos ) {
msgid = atoi(payload.substr(0, pos+1).c_str()); msgid = atoi(payload.substr(0, pos+1).c_str());
} }
payload.erase(0, pos+1); payload.erase(0, pos+1);
pos = payload.find(":"); pos = payload.find(":");
if(pos != std::string::npos) if(pos != std::string::npos)
{ {
endpoint = payload.substr(0, pos); endpoint = payload.substr(0, pos);
payload.erase(0, pos+1); payload.erase(0, pos+1);
} }
else else
{ {
endpoint = payload; endpoint = payload;
} }
if (endpoint == "") endpoint = "/"; if (endpoint == "") endpoint = "/";
s_data = payload; s_data = payload;
SIOClient *c = NULL; SIOClient *c = NULL;
c = getClient(endpoint); c = getClient(endpoint);
if (c == NULL) log("SIOClientImpl::onMessage client lookup returned NULL"); if (c == NULL) log("SIOClientImpl::onMessage client lookup returned NULL");
switch(control) switch(control)
{ {
case 0: case 0:
log("Received Disconnect Signal for Endpoint: %s\n", endpoint.c_str()); log("Received Disconnect Signal for Endpoint: %s\n", endpoint.c_str());
if(c) c->receivedDisconnect(); if(c) c->receivedDisconnect();
disconnectFromEndpoint(endpoint); disconnectFromEndpoint(endpoint);
break; break;
case 1: case 1:
log("Connected to endpoint: %s \n",endpoint.c_str()); log("Connected to endpoint: %s \n",endpoint.c_str());
if(c) c->onConnect(); if(c) c->onConnect();
break; break;
case 2: case 2:
log("Heartbeat received\n"); log("Heartbeat received\n");
break; break;
case 3: case 3:
log("Message received: %s \n", s_data.c_str()); log("Message received: %s \n", s_data.c_str());
if(c) c->getDelegate()->onMessage(c, s_data); if(c) c->getDelegate()->onMessage(c, s_data);
break; break;
case 4: case 4:
log("JSON Message Received: %s \n", s_data.c_str()); log("JSON Message Received: %s \n", s_data.c_str());
if(c) c->getDelegate()->onMessage(c, s_data); if(c) c->getDelegate()->onMessage(c, s_data);
break; break;
case 5: case 5:
log("Event Received with data: %s \n", s_data.c_str()); log("Event Received with data: %s \n", s_data.c_str());
if(c) if(c)
{ {
eventname = ""; eventname = "";
pos = s_data.find(":"); pos = s_data.find(":");
pos2 = s_data.find(","); pos2 = s_data.find(",");
if(pos2 > pos) if(pos2 > pos)
{ {
s_data = s_data.substr(pos+1, pos2-pos-1); s_data = s_data.substr(pos+1, pos2-pos-1);
std::remove_copy(s_data.begin(), s_data.end(), std::remove_copy(s_data.begin(), s_data.end(),
std::back_inserter(eventname), '"'); std::back_inserter(eventname), '"');
} }
c->fireEvent(eventname, payload); c->fireEvent(eventname, payload);
} }
break; break;
case 6: case 6:
log("Message Ack\n"); log("Message Ack\n");
break; break;
case 7: case 7:
log("Error\n"); log("Error\n");
if(c) c->getDelegate()->onError(c, s_data); if(c) c->getDelegate()->onError(c, s_data);
break; break;
case 8: case 8:
log("Noop\n"); log("Noop\n");
break; break;
} }
return; return;
} }
void SIOClientImpl::onClose(WebSocket* ws) void SIOClientImpl::onClose(WebSocket* ws)
@ -467,11 +467,11 @@ void SIOClientImpl::onClose(WebSocket* ws)
{ {
for (auto iter = _clients.begin(); iter != _clients.end(); ++iter) for (auto iter = _clients.begin(); iter != _clients.end(); ++iter)
{ {
iter->second->receivedDisconnect(); iter->second->receivedDisconnect();
} }
} }
this->release(); this->release();
} }
void SIOClientImpl::onError(WebSocket* ws, const WebSocket::ErrorCode& error) void SIOClientImpl::onError(WebSocket* ws, const WebSocket::ErrorCode& error)
@ -480,103 +480,105 @@ void SIOClientImpl::onError(WebSocket* ws, const WebSocket::ErrorCode& error)
//begin SIOClient methods //begin SIOClient methods
SIOClient::SIOClient(const std::string& host, int port, const std::string& path, SIOClientImpl* impl, SocketIO::SIODelegate& delegate) SIOClient::SIOClient(const std::string& host, int port, const std::string& path, SIOClientImpl* impl, SocketIO::SIODelegate& delegate)
: _port(port) : _port(port)
, _host(host) , _host(host)
, _path(path) , _path(path)
, _connected(false) , _connected(false)
, _socket(impl) , _socket(impl)
, _delegate(&delegate) , _delegate(&delegate)
{ {
} }
SIOClient::~SIOClient(void) SIOClient::~SIOClient(void)
{ {
if (_connected) if (_connected)
{ {
_socket->disconnectFromEndpoint(_path); _socket->disconnectFromEndpoint(_path);
} }
} }
void SIOClient::onOpen() void SIOClient::onOpen()
{ {
if (_path != "/") if (_path != "/")
{ {
_socket->connectToEndpoint(_path); _socket->connectToEndpoint(_path);
} }
} }
void SIOClient::onConnect() void SIOClient::onConnect()
{ {
_connected = true; _connected = true;
_delegate->onConnect(this); _delegate->onConnect(this);
} }
void SIOClient::send(std::string s) void SIOClient::send(std::string s)
{ {
if (_connected) if (_connected)
{ {
_socket->send(_path, s); _socket->send(_path, s);
} }
else else
{ {
_delegate->onError(this, "Client not yet connected"); _delegate->onError(this, "Client not yet connected");
} }
} }
void SIOClient::emit(std::string eventname, std::string args) void SIOClient::emit(std::string eventname, std::string args)
{ {
if(_connected) if(_connected)
{ {
_socket->emit(_path, eventname, args); _socket->emit(_path, eventname, args);
} }
else else
{ {
_delegate->onError(this, "Client not yet connected"); _delegate->onError(this, "Client not yet connected");
} }
} }
void SIOClient::disconnect() void SIOClient::disconnect()
{ {
_connected = false; _connected = false;
_socket->disconnectFromEndpoint(_path); _socket->disconnectFromEndpoint(_path);
_delegate->onClose(this); _delegate->onClose(this);
this->release(); this->release();
} }
void SIOClient::receivedDisconnect() void SIOClient::receivedDisconnect()
{ {
_connected = false; _connected = false;
_delegate->onClose(this); _delegate->onClose(this);
this->release(); this->release();
} }
void SIOClient::on(const std::string& eventName, SIOEvent e) void SIOClient::on(const std::string& eventName, SIOEvent e)
{ {
_eventRegistry[eventName] = e; _eventRegistry[eventName] = e;
} }
void SIOClient::fireEvent(const std::string& eventName, const std::string& data) void SIOClient::fireEvent(const std::string& eventName, const std::string& data)
{ {
log("SIOClient::fireEvent called with event name: %s and data: %s", eventName.c_str(), data.c_str()); log("SIOClient::fireEvent called with event name: %s and data: %s", eventName.c_str(), data.c_str());
if(_eventRegistry[eventName]) _delegate->fireEventToScript(this, eventName, data);
if(_eventRegistry[eventName])
{ {
SIOEvent e = _eventRegistry[eventName]; SIOEvent e = _eventRegistry[eventName];
e(this, data); e(this, data);
return; return;
} }
log("SIOClient::fireEvent no event with name %s found", eventName.c_str()); log("SIOClient::fireEvent no native event with name %s found", eventName.c_str());
} }
//begin SocketIO methods //begin SocketIO methods
@ -592,10 +594,10 @@ SocketIO::~SocketIO(void)
SocketIO* SocketIO::getInstance() SocketIO* SocketIO::getInstance()
{ {
if (nullptr == _inst) if (nullptr == _inst)
_inst = new SocketIO(); _inst = new SocketIO();
return _inst; return _inst;
} }
void SocketIO::destroyInstance() void SocketIO::destroyInstance()
@ -605,89 +607,96 @@ void SocketIO::destroyInstance()
SIOClient* SocketIO::connect(SocketIO::SIODelegate& delegate, const std::string& uri) SIOClient* SocketIO::connect(SocketIO::SIODelegate& delegate, const std::string& uri)
{ {
std::string host = uri;
int port = 0; return SocketIO::connect(uri, delegate);
}
SIOClient* SocketIO::connect(const std::string& uri, SocketIO::SIODelegate& delegate)
{
std::string host = uri;
int port = 0;
size_t pos = 0; size_t pos = 0;
pos = host.find("//"); pos = host.find("//");
if (pos != std::string::npos) if (pos != std::string::npos)
{ {
host.erase(0, pos+2); host.erase(0, pos+2);
} }
pos = host.find(":"); pos = host.find(":");
if (pos != std::string::npos) if (pos != std::string::npos)
{ {
port = atoi(host.substr(pos+1, host.size()).c_str()); port = atoi(host.substr(pos+1, host.size()).c_str());
} }
pos = host.find("/", 0); pos = host.find("/", 0);
std::string path = "/"; std::string path = "/";
if (pos != std::string::npos) if (pos != std::string::npos)
{ {
path += host.substr(pos + 1, host.size()); path += host.substr(pos + 1, host.size());
} }
pos = host.find(":"); pos = host.find(":");
if (pos != std::string::npos) if (pos != std::string::npos)
{ {
host.erase(pos, host.size()); host.erase(pos, host.size());
} }
else if ((pos = host.find("/")) != std::string::npos) else if ((pos = host.find("/")) != std::string::npos)
{ {
host.erase(pos, host.size()); host.erase(pos, host.size());
} }
std::stringstream s; std::stringstream s;
s << host << ":" << port; s << host << ":" << port;
SIOClientImpl* socket = nullptr; SIOClientImpl* socket = nullptr;
SIOClient *c = nullptr; SIOClient *c = nullptr;
socket = SocketIO::getInstance()->getSocket(s.str()); socket = SocketIO::getInstance()->getSocket(s.str());
if(socket == nullptr) if(socket == nullptr)
{ {
//create a new socket, new client, connect //create a new socket, new client, connect
socket = SIOClientImpl::create(host, port); socket = SIOClientImpl::create(host, port);
c = new SIOClient(host, port, path, socket, delegate); c = new SIOClient(host, port, path, socket, delegate);
socket->addClient(path, c); socket->addClient(path, c);
socket->connect(); socket->connect();
} }
else else
{ {
//check if already connected to endpoint, handle //check if already connected to endpoint, handle
c = socket->getClient(path); c = socket->getClient(path);
if(c == NULL) if(c == NULL)
{ {
c = new SIOClient(host, port, path, socket, delegate); c = new SIOClient(host, port, path, socket, delegate);
socket->addClient(path, c); socket->addClient(path, c);
socket->connectToEndpoint(path); socket->connectToEndpoint(path);
} }
} }
return c; return c;
} }
SIOClientImpl* SocketIO::getSocket(const std::string& uri) SIOClientImpl* SocketIO::getSocket(const std::string& uri)
{ {
return _sockets.at(uri); return _sockets.at(uri);
} }
void SocketIO::addSocket(const std::string& uri, SIOClientImpl* socket) void SocketIO::addSocket(const std::string& uri, SIOClientImpl* socket)
{ {
_sockets.insert(uri, socket); _sockets.insert(uri, socket);
} }
void SocketIO::removeSocket(const std::string& uri) void SocketIO::removeSocket(const std::string& uri)
{ {
_sockets.erase(uri); _sockets.erase(uri);
} }
} }

95
cocos/network/SocketIO.h
View File

@ -27,32 +27,32 @@ Usage is described below, a full working example can be found in TestCpp under E
creating a new connection to a socket.io server running at localhost:3000 creating a new connection to a socket.io server running at localhost:3000
SIOClient *client = SocketIO::connect(*delegate, "ws://localhost:3000"); SIOClient *client = SocketIO::connect(*delegate, "ws://localhost:3000");
the connection process will begin and if successful delegate::onOpen will be called the connection process will begin and if successful delegate::onOpen will be called
if the connection process results in an error, delegate::onError will be called with the err msg if the connection process results in an error, delegate::onError will be called with the err msg
sending a message to the server sending a message to the server
client->send("Hello!"); client->send("Hello!");
emitting an event to be handled by the server, argument json formatting is up to you emitting an event to be handled by the server, argument json formatting is up to you
client->emit("eventname", "[{\"arg\":\"value\"}]"); client->emit("eventname", "[{\"arg\":\"value\"}]");
registering an event callback, target should be a member function in a subclass of SIODelegate registering an event callback, target should be a member function in a subclass of SIODelegate
CC_CALLBACK_2 is used to wrap the callback with std::bind and store as an SIOEvent CC_CALLBACK_2 is used to wrap the callback with std::bind and store as an SIOEvent
client->on("eventname", CC_CALLBACK_2(TargetClass::targetfunc, *targetclass_instance)); client->on("eventname", CC_CALLBACK_2(TargetClass::targetfunc, *targetclass_instance));
event target function should match this pattern, *this pointer will be made available event target function should match this pattern, *this pointer will be made available
void TargetClass::targetfunc(SIOClient *, const std::string&) void TargetClass::targetfunc(SIOClient *, const std::string&)
disconnect from the endpoint by calling disconnect(), onClose will be called on the delegate once complete disconnect from the endpoint by calling disconnect(), onClose will be called on the delegate once complete
in the onClose method the pointer should be set to NULL or used to connect to a new endpoint in the onClose method the pointer should be set to NULL or used to connect to a new endpoint
client->disconnect(); client->disconnect();
****************************************************************************/ ****************************************************************************/
@ -78,44 +78,47 @@ class SIOClient;
class SocketIO class SocketIO
{ {
public: public:
static SocketIO* getInstance(); static SocketIO* getInstance();
static void destroyInstance(); static void destroyInstance();
/** /**
* @brief The delegate class to process socket.io events * @brief The delegate class to process socket.io events
*/ */
class SIODelegate class SIODelegate
{ {
public: public:
virtual ~SIODelegate() {} virtual ~SIODelegate() {}
virtual void onConnect(SIOClient* client) = 0; virtual void onConnect(SIOClient* client) = 0;
virtual void onMessage(SIOClient* client, const std::string& data) = 0; virtual void onMessage(SIOClient* client, const std::string& data) = 0;
virtual void onClose(SIOClient* client) = 0; virtual void onClose(SIOClient* client) = 0;
virtual void onError(SIOClient* client, const std::string& data) = 0; virtual void onError(SIOClient* client, const std::string& data) = 0;
virtual void fireEventToScript(SIOClient* client, const std::string& eventName, const std::string& data) { CCLOG("SIODelegate event '%s' fired with data: %s", eventName.c_str(), data.c_str()); };
}; };
/** /**
* @brief Static client creation method, similar to socketio.connect(uri) in JS * @brief Static client creation method, similar to socketio.connect(uri) in JS
* @param delegate The delegate which want to receive events from the socket.io client * @param delegate The delegate which want to receive events from the socket.io client
* @param uri The URI of the socket.io server * @param uri The URI of the socket.io server
* @return An initialized SIOClient if connected successfully, otherwise NULL * @return An initialized SIOClient if connected successfully, otherwise NULL
*/ */
static SIOClient* connect(SocketIO::SIODelegate& delegate, const std::string& uri); static SIOClient* connect(const std::string& uri, SocketIO::SIODelegate& delegate);
CC_DEPRECATED_ATTRIBUTE static SIOClient* connect(SocketIO::SIODelegate& delegate, const std::string& uri);
private: private:
SocketIO(); SocketIO();
virtual ~SocketIO(void); virtual ~SocketIO(void);
static SocketIO *_inst; static SocketIO *_inst;
cocos2d::Map<std::string, SIOClientImpl*> _sockets; cocos2d::Map<std::string, SIOClientImpl*> _sockets;
SIOClientImpl* getSocket(const std::string& uri); SIOClientImpl* getSocket(const std::string& uri);
void addSocket(const std::string& uri, SIOClientImpl* socket); void addSocket(const std::string& uri, SIOClientImpl* socket);
void removeSocket(const std::string& uri); void removeSocket(const std::string& uri);
friend class SIOClientImpl; friend class SIOClientImpl;
private: private:
CC_DISALLOW_COPY_AND_ASSIGN(SocketIO) CC_DISALLOW_COPY_AND_ASSIGN(SocketIO)
}; };
@ -129,59 +132,59 @@ typedef std::unordered_map<std::string, SIOEvent> EventRegistry;
* @brief A single connection to a socket.io endpoint * @brief A single connection to a socket.io endpoint
*/ */
class SIOClient class SIOClient
: public cocos2d::Ref : public cocos2d::Ref
{ {
private: private:
int _port; int _port;
std::string _host, _path, _tag; std::string _host, _path, _tag;
bool _connected; bool _connected;
SIOClientImpl* _socket; SIOClientImpl* _socket;
SocketIO::SIODelegate* _delegate; SocketIO::SIODelegate* _delegate;
EventRegistry _eventRegistry; EventRegistry _eventRegistry;
void fireEvent(const std::string& eventName, const std::string& data); void fireEvent(const std::string& eventName, const std::string& data);
void onOpen(); void onOpen();
void onConnect(); void onConnect();
void receivedDisconnect(); void receivedDisconnect();
friend class SIOClientImpl; friend class SIOClientImpl;
public: public:
SIOClient(const std::string& host, int port, const std::string& path, SIOClientImpl* impl, SocketIO::SIODelegate& delegate); SIOClient(const std::string& host, int port, const std::string& path, SIOClientImpl* impl, SocketIO::SIODelegate& delegate);
virtual ~SIOClient(void); virtual ~SIOClient(void);
/** /**
* @brief Returns the delegate for the client * @brief Returns the delegate for the client
*/ */
SocketIO::SIODelegate* getDelegate() { return _delegate; }; SocketIO::SIODelegate* getDelegate() { return _delegate; };
/** /**
* @brief Disconnect from the endpoint, onClose will be called on the delegate when comlpete * @brief Disconnect from the endpoint, onClose will be called on the delegate when comlpete
*/ */
void disconnect(); void disconnect();
/** /**
* @brief Send a message to the socket.io server * @brief Send a message to the socket.io server
*/ */
void send(std::string s); void send(std::string s);
/** /**
* @brief The delegate class to process socket.io events * @brief The delegate class to process socket.io events
*/ */
void emit(std::string eventname, std::string args); void emit(std::string eventname, std::string args);
/** /**
* @brief Used to resgister a socket.io event callback * @brief Used to resgister a socket.io event callback
* Event argument should be passed using CC_CALLBACK2(&Base::function, this) * Event argument should be passed using CC_CALLBACK2(&Base::function, this)
*/ */
void on(const std::string& eventName, SIOEvent e); void on(const std::string& eventName, SIOEvent e);
inline void setTag(const char* tag) inline void setTag(const char* tag)
{ {
_tag = tag; _tag = tag;
}; };
inline const char* getTag() inline const char* getTag()
{ {
return _tag.c_str(); return _tag.c_str();
}; };

2
cocos/network/WebSocket.h
View File

@ -151,7 +151,7 @@ private:
void *user, void *in, ssize_t len); void *user, void *in, ssize_t len);
private: private:
State _readyState; State _readyState;
std::string _host; std::string _host;
unsigned int _port; unsigned int _port;
std::string _path; std::string _path;