mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
343 lines
9.7 KiB
C++
343 lines
9.7 KiB
C++
#include "jsb_socketio.hpp"
|
|
|
|
#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
|
|
#include "cocos/scripting/js-bindings/manual/jsb_conversions.hpp"
|
|
#include "cocos/scripting/js-bindings/manual/jsb_global.h"
|
|
|
|
#include "cocos/network/SocketIO.h"
|
|
#include "base/ccUTF8.h"
|
|
#include "base/CCDirector.h"
|
|
|
|
using namespace cocos2d;
|
|
using namespace cocos2d::network;
|
|
|
|
se::Class* __jsb_SocketIO_class = nullptr;
|
|
|
|
class JSB_SocketIODelegate : public Ref, public SocketIO::SIODelegate
|
|
{
|
|
public:
|
|
|
|
//c++11 map to callbacks
|
|
typedef std::unordered_map<std::string/* eventName */, se::ValueArray/* 0:callbackFunc, 1:target */> JSB_SIOCallbackRegistry;
|
|
|
|
JSB_SocketIODelegate()
|
|
{
|
|
}
|
|
|
|
virtual ~JSB_SocketIODelegate()
|
|
{
|
|
CCLOGINFO("In the destructor of JSB_SocketIODelegate(%p)", this);
|
|
}
|
|
|
|
virtual void onConnect(SIOClient* client) override
|
|
{
|
|
}
|
|
|
|
virtual void onMessage(SIOClient* client, const std::string& data) override
|
|
{
|
|
}
|
|
|
|
virtual void onClose(SIOClient* client) override
|
|
{
|
|
CCLOG("JSB SocketIO::SIODelegate->onClose method called from native");
|
|
this->fireEventToScript(client, "disconnect", "");
|
|
release();
|
|
}
|
|
|
|
virtual void onError(SIOClient* client, const std::string& data) override
|
|
{
|
|
CCLOG("JSB SocketIO::SIODelegate->onError method called from native with data: %s", data.c_str());
|
|
this->fireEventToScript(client, "error", data);
|
|
}
|
|
|
|
virtual void fireEventToScript(SIOClient* client, const std::string& eventName, const std::string& data) override
|
|
{
|
|
CCLOG("JSB SocketIO::SIODelegate->fireEventToScript method called from native with name '%s' data: %s", eventName.c_str(), data.c_str());
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
se::AutoHandleScope hs;
|
|
|
|
if (cocos2d::Director::getInstance() == nullptr || cocos2d::ScriptEngineManager::getInstance() == nullptr)
|
|
return;
|
|
|
|
auto iter = se::__nativePtrToObjectMap.find(client); //FIXME: client probably be a new value with the same address as the old one, it may cause undefined result.
|
|
if (iter == se::__nativePtrToObjectMap.end())
|
|
return;
|
|
|
|
se::Value dataVal;
|
|
if (data.empty())
|
|
{
|
|
dataVal.setNull();
|
|
}
|
|
else
|
|
{
|
|
dataVal.setString(data);
|
|
}
|
|
|
|
JSB_SIOCallbackRegistry::iterator it = _eventRegistry.find(eventName);
|
|
|
|
if (it != _eventRegistry.end())
|
|
{
|
|
const se::ValueArray& cbStruct = it->second;
|
|
assert(cbStruct.size() == 2);
|
|
const se::Value& callback = cbStruct[0];
|
|
const se::Value& target = cbStruct[1];
|
|
if (callback.isObject() && callback.toObject()->isFunction() && target.isObject())
|
|
{
|
|
se::ValueArray args;
|
|
args.push_back(dataVal);
|
|
callback.toObject()->call(args, target.toObject());
|
|
}
|
|
}
|
|
|
|
if (eventName == "disconnect")
|
|
{
|
|
cocos2d::log("disconnect ... "); //FIXME:
|
|
}
|
|
}
|
|
|
|
void addEvent(const std::string& eventName, const se::Value& callback, const se::Value& target)
|
|
{
|
|
assert(callback.isObject() && callback.toObject()->isFunction());
|
|
assert(target.isObject());
|
|
_eventRegistry[eventName].clear();
|
|
_eventRegistry[eventName].push_back(callback);
|
|
_eventRegistry[eventName].push_back(target);
|
|
target.toObject()->attachChild(callback.toObject());
|
|
}
|
|
|
|
private:
|
|
JSB_SIOCallbackRegistry _eventRegistry;
|
|
};
|
|
|
|
|
|
static bool SocketIO_finalize(se::State& s)
|
|
{
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (SocketIO)", cobj);
|
|
cobj->disconnect();
|
|
static_cast<JSB_SocketIODelegate*>(cobj->getDelegate())->release();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(SocketIO_finalize)
|
|
|
|
|
|
static bool SocketIO_prop_getTag(se::State& s)
|
|
{
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
s.rval().setString(cobj->getTag());
|
|
return true;
|
|
}
|
|
SE_BIND_PROP_GET(SocketIO_prop_getTag)
|
|
|
|
static bool SocketIO_prop_setTag(se::State& s)
|
|
{
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
cobj->setTag(s.args()[0].toString().c_str());
|
|
return true;
|
|
}
|
|
SE_BIND_PROP_SET(SocketIO_prop_setTag)
|
|
|
|
static bool SocketIO_send(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
int argc = (int)args.size();
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
|
|
if (argc == 1)
|
|
{
|
|
std::string payload;
|
|
bool ok = seval_to_std_string(args[0], &payload);
|
|
SE_PRECONDITION2(ok, false, "Converting payload failed!");
|
|
|
|
cobj->send(payload);
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("Wrong number of arguments: %d, expected: %d", argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(SocketIO_send)
|
|
|
|
static bool SocketIO_emit(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
int argc = (int)args.size();
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
|
|
if (argc == 2)
|
|
{
|
|
bool ok = false;
|
|
std::string eventName;
|
|
ok = seval_to_std_string(args[0], &eventName);
|
|
SE_PRECONDITION2(ok, false, "Converting eventName failed!");
|
|
|
|
std::string payload;
|
|
ok = seval_to_std_string(args[1], &payload);
|
|
SE_PRECONDITION2(ok, false, "Converting payload failed!");
|
|
|
|
CCLOG("JSB SocketIO emit event '%s' with payload: %s", eventName.c_str(), payload.c_str());
|
|
|
|
cobj->emit(eventName, payload);
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("Wrong number of arguments: %d, expected: %d", argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(SocketIO_emit)
|
|
|
|
static bool SocketIO_disconnect(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
int argc = (int)args.size();
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
|
|
if (argc == 0)
|
|
{
|
|
cobj->disconnect();
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("Wrong number of arguments: %d, expected: %d", argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(SocketIO_disconnect)
|
|
|
|
static bool SocketIO_on(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
int argc = (int)args.size();
|
|
SIOClient* cobj = (SIOClient*)s.nativeThisObject();
|
|
|
|
if (argc == 2)
|
|
{
|
|
bool ok = false;
|
|
std::string eventName;
|
|
ok = seval_to_std_string(args[0], &eventName);
|
|
SE_PRECONDITION2(ok, false, "Converting eventName failed!");
|
|
|
|
CCLOG("JSB SocketIO eventName to: '%s'", eventName.c_str());
|
|
|
|
((JSB_SocketIODelegate *)cobj->getDelegate())->addEvent(eventName, args[1], se::Value(s.thisObject()));
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("Wrong number of arguments: %d, expected: %d", argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(SocketIO_on)
|
|
|
|
// static
|
|
static bool SocketIO_connect(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
int argc = (int)args.size();
|
|
CCLOG("JSB SocketIO.connect method called");
|
|
|
|
if (argc >= 1 && argc <= 3)
|
|
{
|
|
std::string url;
|
|
std::string caFilePath;
|
|
bool ok = false;
|
|
|
|
ok = seval_to_std_string(args[0], &url);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
|
|
if (argc == 2)
|
|
{
|
|
if (args[1].isObject())
|
|
{
|
|
// Just ignore the option argument
|
|
}
|
|
else if (args[1].isString())
|
|
{
|
|
// Assume it's CA root file path
|
|
ok = seval_to_std_string(args[1], &caFilePath);
|
|
SE_PRECONDITION2( ok, false, "Error processing arguments");
|
|
}
|
|
}
|
|
|
|
if (argc == 3)
|
|
{
|
|
// Just ignore the option argument
|
|
|
|
if (args[2].isString())
|
|
{
|
|
// Assume it's CA root file path
|
|
ok = seval_to_std_string(args[2], &caFilePath);
|
|
SE_PRECONDITION2( ok, false, "Error processing arguments");
|
|
}
|
|
}
|
|
|
|
JSB_SocketIODelegate* siodelegate = new (std::nothrow) JSB_SocketIODelegate();
|
|
|
|
CCLOG("Calling native SocketIO.connect method");
|
|
SIOClient* ret = SocketIO::connect(url, *siodelegate, caFilePath);
|
|
if (ret != nullptr)
|
|
{
|
|
ret->retain();
|
|
siodelegate->retain();
|
|
|
|
se::Object* obj = se::Object::createObjectWithClass(__jsb_SocketIO_class);
|
|
obj->setPrivateData(ret);
|
|
|
|
s.rval().setObject(obj);
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
siodelegate->release();
|
|
SE_REPORT_ERROR("SocketIO.connect return nullptr!");
|
|
return false;
|
|
}
|
|
}
|
|
SE_REPORT_ERROR("JSB SocketIO.connect: Wrong number of arguments");
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(SocketIO_connect)
|
|
|
|
// static
|
|
static bool SocketIO_close(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
int argc = (int)args.size();
|
|
if (argc == 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("Wrong number of arguments: %d, expected: %d", argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(SocketIO_close)
|
|
|
|
bool register_all_socketio(se::Object* obj)
|
|
{
|
|
se::Class* cls = se::Class::create("SocketIO", obj, nullptr, nullptr);
|
|
cls->defineFinalizeFunction(_SE(SocketIO_finalize));
|
|
|
|
cls->defineProperty("tag", _SE(SocketIO_prop_getTag), _SE(SocketIO_prop_setTag));
|
|
|
|
cls->defineFunction("send", _SE(SocketIO_send));
|
|
cls->defineFunction("emit", _SE(SocketIO_emit));
|
|
cls->defineFunction("disconnect", _SE(SocketIO_disconnect));
|
|
cls->defineFunction("on", _SE(SocketIO_on));
|
|
|
|
cls->install();
|
|
|
|
JSBClassType::registerClass<SocketIO>(cls);
|
|
|
|
se::Value ctorVal;
|
|
obj->getProperty("SocketIO", &ctorVal);
|
|
ctorVal.toObject()->defineFunction("connect", _SE(SocketIO_connect));
|
|
ctorVal.toObject()->defineFunction("close", _SE(SocketIO_close));
|
|
|
|
__jsb_SocketIO_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|