Files
cocos4/native/cocos/scripting/js-bindings/manual/jsb_socketio.cpp
T

366 lines
10 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", "");
if (getReferenceCount() == 1)
{
autorelease();
}
else
{
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()->attachObject(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();
JSB_SocketIODelegate* delegate = static_cast<JSB_SocketIODelegate*>(cobj->getDelegate());
if (delegate->getReferenceCount() == 1)
{
delegate->autorelease();
}
else
{
delegate->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 >= 1)
{
bool ok = false;
std::string eventName;
ok = seval_to_std_string(args[0], &eventName);
SE_PRECONDITION2(ok, false, "Converting eventName failed!");
std::string payload;
if (argc >= 2)
{
const auto& arg1 = args[1];
// Add this check to make it compatible with old version.
// jsval_to_std_string in v1.6 returns empty string if arg1 is null or undefined
// while seval_to_std_string since 1.7.2 follows JS standard to return "null" or "undefined".
// Therefore, we need a workaround to make it be compatible with versions lower than v1.7.
if (!arg1.isNullOrUndefined())
{
ok = seval_to_std_string(arg1, &payload);
SE_PRECONDITION2(ok, false, "Converting payload failed!");
}
}
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;
}