Files
cocos4/native/cocos/bindings/manual/jsb_cocos_manual.cpp
T
2022-01-24 17:23:03 +08:00

683 lines
27 KiB
C++

/****************************************************************************
Copyright (c) 2017-2022 Xiamen Yaji Software Co., Ltd.
http://www.cocos.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated engine source code (the "Software"), a limited,
worldwide, royalty-free, non-assignable, revocable and non-exclusive license
to use Cocos Creator solely to develop games on your target platforms. You shall
not use Cocos Creator software for developing other software or tools that's
used for developing games. You are not granted to publish, distribute,
sublicense, and/or sell copies of Cocos Creator.
The software or tools in this License Agreement are licensed, not sold.
Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "jsb_cocos_manual.h"
#include "cocos/bindings/auto/jsb_cocos_auto.h"
#include "cocos/bindings/jswrapper/SeApi.h"
#include "cocos/bindings/manual/jsb_conversions.h"
#include "cocos/bindings/manual/jsb_global_init.h"
#include "storage/local-storage/LocalStorage.h"
extern se::Object *__jsb_cc_FileUtils_proto; // NOLINT(readability-redundant-declaration)
static bool jsb_ccx_empty_func(const se::State & /*s*/) { // NOLINT(readability-identifier-naming)
return true;
}
SE_BIND_FUNC(jsb_ccx_empty_func) // NOLINT(readability-identifier-naming)
class JSPlistDelegator : public cc::SAXDelegator {
public:
static JSPlistDelegator *getInstance() {
static JSPlistDelegator *pInstance = nullptr;
if (pInstance == nullptr) {
pInstance = new (std::nothrow) JSPlistDelegator();
}
return pInstance;
};
~JSPlistDelegator() override;
cc::SAXParser *getParser();
std::string parse(const std::string &path);
std::string parseText(const std::string &text);
// implement pure virtual methods of SAXDelegator
void startElement(void *ctx, const char *name, const char **atts) override;
void endElement(void *ctx, const char *name) override;
void textHandler(void *ctx, const char *ch, int len) override;
private:
cc::SAXParser _parser;
std::string _result;
bool _isStoringCharacters;
std::string _currentValue;
};
// cc.PlistParser.getInstance()
static bool js_PlistParser_getInstance(se::State &s) { // NOLINT(readability-identifier-naming)
JSPlistDelegator *delegator = JSPlistDelegator::getInstance();
cc::SAXParser * parser = delegator->getParser();
if (parser) {
native_ptr_to_rooted_seval<cc::SAXParser>(parser, __jsb_cc_SAXParser_class, &s.rval());
return true;
}
return false;
}
SE_BIND_FUNC(js_PlistParser_getInstance) // NOLINT(readability-identifier-naming)
// cc.PlistParser.getInstance().parse(text)
static bool js_PlistParser_parse(se::State &s) { // NOLINT(readability-identifier-naming)
const auto & args = s.args();
size_t argc = args.size();
JSPlistDelegator *delegator = JSPlistDelegator::getInstance();
bool ok = true;
if (argc == 1) {
std::string arg0;
ok &= seval_to_std_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "Error processing arguments");
std::string parsedStr = delegator->parseText(arg0);
std::replace(parsedStr.begin(), parsedStr.end(), '\n', ' ');
se::Value strVal;
std_string_to_seval(parsedStr, &strVal);
se::HandleObject robj(se::Object::createJSONObject(strVal.toString()));
s.rval().setObject(robj);
return true;
}
SE_REPORT_ERROR("js_PlistParser_parse : wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_PlistParser_parse)
cc::SAXParser *JSPlistDelegator::getParser() {
return &_parser;
}
std::string JSPlistDelegator::parse(const std::string &path) {
_result.clear();
cc::SAXParser parser;
if (parser.init("UTF-8")) {
parser.setDelegator(this);
parser.parse(cc::FileUtils::getInstance()->fullPathForFilename(path));
}
return _result;
}
JSPlistDelegator::~JSPlistDelegator() {
CC_LOG_INFO("deallocing __JSSAXDelegator: %p", this);
}
std::string JSPlistDelegator::parseText(const std::string &text) {
_result.clear();
cc::SAXParser parser;
if (parser.init("UTF-8")) {
parser.setDelegator(this);
parser.parse(text.c_str(), text.size());
}
return _result;
}
void JSPlistDelegator::startElement(void * /*ctx*/, const char *name, const char ** /*atts*/) {
_isStoringCharacters = true;
_currentValue.clear();
std::string elementName{name};
auto end = static_cast<int>(_result.size()) - 1;
if (end >= 0 && _result[end] != '{' && _result[end] != '[' && _result[end] != ':') {
_result += ",";
}
if (elementName == "dict") {
_result += "{";
} else if (elementName == "array") {
_result += "[";
}
}
void JSPlistDelegator::endElement(void * /*ctx*/, const char *name) {
_isStoringCharacters = false;
std::string elementName{name};
if (elementName == "dict") {
_result += "}";
} else if (elementName == "array") {
_result += "]";
} else if (elementName == "key") {
_result += "\"" + _currentValue + "\":";
} else if (elementName == "string") {
_result += "\"" + _currentValue + "\"";
} else if (elementName == "false" || elementName == "true") {
_result += elementName;
} else if (elementName == "real" || elementName == "integer") {
_result += _currentValue;
}
}
void JSPlistDelegator::textHandler(void * /*unused*/, const char *ch, int len) {
std::string text(ch, 0, len);
if (_isStoringCharacters) {
_currentValue += text;
}
}
static bool register_plist_parser(se::Object * /*obj*/) { // NOLINT(readability-identifier-naming)
se::Value v;
__jsbObj->getProperty("PlistParser", &v);
assert(v.isObject());
v.toObject()->defineFunction("getInstance", _SE(js_PlistParser_getInstance));
__jsb_cc_SAXParser_proto->defineFunction("parse", _SE(js_PlistParser_parse));
se::ScriptEngine::getInstance()->clearException();
return true;
}
// cc.sys.localStorage
static bool JSB_localStorageGetItem(se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
size_t argc = args.size();
if (argc == 1) {
bool ok = true;
std::string key;
ok = seval_to_std_string(args[0], &key);
SE_PRECONDITION2(ok, false, "Error processing arguments");
std::string value;
ok = localStorageGetItem(key, &value);
if (ok) {
s.rval().setString(value);
} else {
s.rval().setNull(); // Should return null to make JSB behavior same as Browser since returning undefined will make JSON.parse(undefined) trigger exception.
}
return true;
}
SE_REPORT_ERROR("Invalid number of arguments");
return false;
}
SE_BIND_FUNC(JSB_localStorageGetItem) // NOLINT(readability-identifier-naming)
static bool JSB_localStorageRemoveItem(const se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
size_t argc = args.size();
if (argc == 1) {
bool ok = true;
std::string key;
ok = seval_to_std_string(args[0], &key);
SE_PRECONDITION2(ok, false, "Error processing arguments");
localStorageRemoveItem(key);
return true;
}
SE_REPORT_ERROR("Invalid number of arguments");
return false;
}
SE_BIND_FUNC(JSB_localStorageRemoveItem) // NOLINT(readability-identifier-naming)
static bool JSB_localStorageSetItem(const se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
size_t argc = args.size();
if (argc == 2) {
bool ok = true;
std::string key;
ok = seval_to_std_string(args[0], &key);
SE_PRECONDITION2(ok, false, "Error processing arguments");
std::string value;
ok = seval_to_std_string(args[1], &value);
SE_PRECONDITION2(ok, false, "Error processing arguments");
localStorageSetItem(key, value);
return true;
}
SE_REPORT_ERROR("Invalid number of arguments");
return false;
}
SE_BIND_FUNC(JSB_localStorageSetItem) // NOLINT(readability-identifier-naming)
static bool JSB_localStorageClear(const se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
size_t argc = args.size();
if (argc == 0) {
localStorageClear();
return true;
}
SE_REPORT_ERROR("Invalid number of arguments");
return false;
}
SE_BIND_FUNC(JSB_localStorageClear) // NOLINT(readability-identifier-naming)
static bool JSB_localStorageKey(se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
size_t argc = args.size();
if (argc == 1) {
bool ok = true;
int nIndex = 0;
ok = seval_to_int32(args[0], &nIndex);
SE_PRECONDITION2(ok, false, "Error processing arguments");
std::string value;
localStorageGetKey(nIndex, &value);
s.rval().setString(value);
return true;
}
SE_REPORT_ERROR("Invalid number of arguments");
return false;
}
SE_BIND_FUNC(JSB_localStorageKey) // NOLINT(readability-identifier-naming)
static bool JSB_localStorage_getLength(se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
size_t argc = args.size();
if (argc == 0) {
int nLength = 0;
localStorageGetLength(nLength);
s.rval().setInt32(nLength);
return true;
}
SE_REPORT_ERROR("Invalid number of arguments");
return false;
}
SE_BIND_PROP_GET(JSB_localStorage_getLength); // NOLINT(readability-identifier-naming)
static bool register_sys_localStorage(se::Object *obj) { // NOLINT(readability-identifier-naming)
se::Value sys;
if (!obj->getProperty("sys", &sys)) {
se::HandleObject sysObj(se::Object::createPlainObject());
obj->setProperty("sys", se::Value(sysObj));
sys.setObject(sysObj);
}
se::HandleObject localStorageObj(se::Object::createPlainObject());
sys.toObject()->setProperty("localStorage", se::Value(localStorageObj));
localStorageObj->defineFunction("getItem", _SE(JSB_localStorageGetItem));
localStorageObj->defineFunction("removeItem", _SE(JSB_localStorageRemoveItem));
localStorageObj->defineFunction("setItem", _SE(JSB_localStorageSetItem));
localStorageObj->defineFunction("clear", _SE(JSB_localStorageClear));
localStorageObj->defineFunction("key", _SE(JSB_localStorageKey));
localStorageObj->defineProperty("length", _SE(JSB_localStorage_getLength), nullptr);
std::string strFilePath = cc::FileUtils::getInstance()->getWritablePath();
#if defined(__QNX__)
// In the QNX environment, the execution of this statement will not take effect.
// Not sure why
// strFilePath += "/jsb.sqlite";
// Use another way
char path[256] = {0};
sprintf(path, "%s/jsb.sqlite", strFilePath.c_str());
localStorageInit(path);
#else
strFilePath += "/jsb.sqlite";
localStorageInit(strFilePath);
#endif
se::ScriptEngine::getInstance()->addBeforeCleanupHook([]() {
localStorageFree();
});
se::ScriptEngine::getInstance()->clearException();
return true;
}
//IDEA: move to auto bindings.
static bool js_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback(se::State &s) { // NOLINT(readability-identifier-naming)
auto *cobj = static_cast<cc::ICanvasRenderingContext2D *>(s.nativeThisObject());
SE_PRECONDITION2(cobj, false, "js_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback : Invalid Native Object");
const auto & args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 1) {
std::function<void(const cc::Data &)> arg0;
do {
if (args[0].isObject() && args[0].toObject()->isFunction()) {
se::Value jsThis(s.thisObject());
se::Value jsFunc(args[0]);
jsThis.toObject()->attachObject(jsFunc.toObject());
auto lambda = [=](const cc::Data &larg0) -> void {
se::ScriptEngine::getInstance()->clearException();
se::AutoHandleScope hs;
CC_UNUSED bool ok = true;
se::ValueArray args;
args.resize(1);
ok &= Data_to_seval(larg0, &args[0]);
se::Value rval;
se::Object *thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
se::Object *funcObj = jsFunc.toObject();
bool succeed = funcObj->call(args, thisObj, &rval);
if (!succeed) {
se::ScriptEngine::getInstance()->clearException();
}
};
// Add an unroot to avoid the root of the copy constructor caused by the internal reference of Lambda.
if (jsThis.isObject()) {
jsThis.toObject()->unroot();
}
jsFunc.toObject()->unroot();
arg0 = lambda;
} else {
arg0 = nullptr;
}
} while (false);
SE_PRECONDITION2(ok, false, "js_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback : Error processing arguments");
cobj->setCanvasBufferUpdatedCallback(arg0);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback) // NOLINT(readability-identifier-naming)
static void setCanvasRenderingContext2DProps(cc::ICanvasRenderingContext2D *context, const se::Value &val) {
se::Object *props = val.toObject();
se::Value propVal;
props->getProperty("lineWidth", &propVal);
if (!propVal.isUndefined()) context->setLineWidth(propVal.toFloat());
props->getProperty("lineJoin", &propVal);
if (!propVal.isUndefined()) context->setLineJoin(propVal.toString());
props->getProperty("fillStyle", &propVal);
if (!propVal.isUndefined()) context->setFillStyle(propVal.toString());
props->getProperty("font", &propVal);
if (!propVal.isUndefined()) context->setFont(propVal.toString());
props->getProperty("lineCap", &propVal);
if (!propVal.isUndefined()) context->setLineCap(propVal.toString());
props->getProperty("textAlign", &propVal);
if (!propVal.isUndefined()) context->setTextAlign(propVal.toString());
props->getProperty("textBaseline", &propVal);
if (!propVal.isUndefined()) context->setTextBaseline(propVal.toString());
props->getProperty("strokeStyle", &propVal);
if (!propVal.isUndefined()) context->setStrokeStyle(propVal.toString());
props->getProperty("globalCompositeOperation", &propVal);
if (!propVal.isUndefined()) context->setGlobalCompositeOperation(propVal.toString());
}
static bool js_engine_CanvasRenderingContext2D_measureText(se::State &s) { // NOLINT(readability-identifier-naming)
auto *cobj = static_cast<cc::ICanvasRenderingContext2D *>(s.nativeThisObject());
SE_PRECONDITION2(cobj, false, "js_engine_CanvasRenderingContext2D_measureText : Invalid Native Object");
const auto & args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 2) {
std::string arg0;
ok &= seval_to_std_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_measureText : Error processing arguments");
SE_PRECONDITION2(args[1].isObject(), false, "js_engine_CanvasRenderingContext2D_fillText : no attributes set.");
setCanvasRenderingContext2DProps(cobj, args[1]);
cc::Size result = cobj->measureText(arg0);
ok &= Size_to_seval(result, &s.rval());
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_measureText : Error processing arguments");
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
return false;
}
SE_BIND_FUNC(js_engine_CanvasRenderingContext2D_measureText) // NOLINT(readability-identifier-naming)
static bool js_engine_CanvasRenderingContext2D_fillRect(const se::State &s) { // NOLINT(readability-identifier-naming)
auto *cobj = static_cast<cc::ICanvasRenderingContext2D *>(s.nativeThisObject());
SE_PRECONDITION2(cobj, false, "js_engine_CanvasRenderingContext2D_fillRect : Invalid Native Object");
const auto & args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 5) {
float arg0 = 0;
float arg1 = 0;
float arg2 = 0;
float arg3 = 0;
ok &= seval_to_float(args[0], &arg0);
ok &= seval_to_float(args[1], &arg1);
ok &= seval_to_float(args[2], &arg2);
ok &= seval_to_float(args[3], &arg3);
SE_PRECONDITION2(args[4].isObject(), false, "js_engine_CanvasRenderingContext2D_fillText : no attributes set.");
setCanvasRenderingContext2DProps(cobj, args[4]);
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_fillRect : Error processing arguments");
cobj->fillRect(arg0, arg1, arg2, arg3);
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
return false;
}
SE_BIND_FUNC(js_engine_CanvasRenderingContext2D_fillRect) // NOLINT(readability-identifier-naming)
static bool js_engine_CanvasRenderingContext2D_fillText(const se::State &s) { // NOLINT(readability-identifier-naming)
auto *cobj = static_cast<cc::ICanvasRenderingContext2D *>(s.nativeThisObject());
SE_PRECONDITION2(cobj, false, "js_engine_CanvasRenderingContext2D_fillText : Invalid Native Object");
const auto & args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 5) {
std::string arg0;
float arg1 = 0;
float arg2 = 0;
float arg3 = 0;
ok &= seval_to_std_string(args[0], &arg0);
ok &= seval_to_float(args[1], &arg1);
ok &= seval_to_float(args[2], &arg2);
SE_PRECONDITION2(args[4].isObject(), false, "js_engine_CanvasRenderingContext2D_fillText : no attributes set.");
setCanvasRenderingContext2DProps(cobj, args[4]);
if (args[3].isUndefined()) {
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_fillText : Error processing arguments");
cobj->fillText(arg0, arg1, arg2, -1.0F);
} else {
ok &= seval_to_float(args[3], &arg3);
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_fillText : Error processing arguments");
cobj->fillText(arg0, arg1, arg2, arg3);
}
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
return false;
}
SE_BIND_FUNC(js_engine_CanvasRenderingContext2D_fillText) // NOLINT(readability-identifier-naming)
static bool js_engine_CanvasRenderingContext2D_strokeText(const se::State &s) { // NOLINT(readability-identifier-naming)
auto *cobj = static_cast<cc::ICanvasRenderingContext2D *>(s.nativeThisObject());
SE_PRECONDITION2(cobj, false, "js_engine_CanvasRenderingContext2D_strokeText : Invalid Native Object");
const auto &args = s.args();
size_t argc = args.size();
bool ok = true;
if (argc == 5) {
std::string arg0;
float arg1 = 0;
float arg2 = 0;
float arg3 = 0;
ok &= seval_to_std_string(args[0], &arg0);
ok &= seval_to_float(args[1], &arg1);
ok &= seval_to_float(args[2], &arg2);
SE_PRECONDITION2(args[4].isObject(), false, "js_engine_CanvasRenderingContext2D_strokeText : no attributes set.");
setCanvasRenderingContext2DProps(cobj, args[4]);
if (!args[3].isUndefined()) {
ok &= seval_to_float(args[3], &arg3);
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_strokeText : Error processing arguments");
cobj->strokeText(arg0, arg1, arg2, arg3);
} else {
SE_PRECONDITION2(ok, false, "js_engine_CanvasRenderingContext2D_strokeText : Error processing arguments");
cobj->strokeText(arg0, arg1, arg2, -1.0F);
}
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
return false;
}
SE_BIND_FUNC(js_engine_CanvasRenderingContext2D_strokeText) // NOLINT(readability-identifier-naming)
static se::Object *deviceMotionObject = nullptr;
static bool JSB_getDeviceMotionValue(se::State &s) { // NOLINT(readability-identifier-naming)
if (deviceMotionObject == nullptr) {
deviceMotionObject = se::Object::createArrayObject(9);
deviceMotionObject->root();
}
const auto &v = cc::Device::getDeviceMotionValue();
deviceMotionObject->setArrayElement(0, se::Value(v.accelerationX));
deviceMotionObject->setArrayElement(1, se::Value(v.accelerationY));
deviceMotionObject->setArrayElement(2, se::Value(v.accelerationZ));
deviceMotionObject->setArrayElement(3, se::Value(v.accelerationIncludingGravityX));
deviceMotionObject->setArrayElement(4, se::Value(v.accelerationIncludingGravityY));
deviceMotionObject->setArrayElement(5, se::Value(v.accelerationIncludingGravityZ));
deviceMotionObject->setArrayElement(6, se::Value(v.rotationRateAlpha));
deviceMotionObject->setArrayElement(7, se::Value(v.rotationRateBeta));
deviceMotionObject->setArrayElement(8, se::Value(v.rotationRateGamma));
s.rval().setObject(deviceMotionObject);
return true;
}
SE_BIND_FUNC(JSB_getDeviceMotionValue) // NOLINT(readability-identifier-naming)
static bool register_device(se::Object * /*obj*/) { // NOLINT(readability-identifier-naming)
se::Value device;
__jsbObj->getProperty("Device", &device);
device.toObject()->defineFunction("getDeviceMotionValue", _SE(JSB_getDeviceMotionValue));
se::ScriptEngine::getInstance()->addBeforeCleanupHook([]() {
if (deviceMotionObject != nullptr) {
deviceMotionObject->unroot();
deviceMotionObject->decRef();
deviceMotionObject = nullptr;
}
});
se::ScriptEngine::getInstance()->clearException();
return true;
}
static bool register_canvas_context2d(se::Object * /*obj*/) { // NOLINT(readability-identifier-naming)
__jsb_cc_CanvasRenderingContext2D_proto->defineFunction("_setCanvasBufferUpdatedCallback", _SE(js_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback));
__jsb_cc_CanvasRenderingContext2D_proto->defineFunction("fillText", _SE(js_engine_CanvasRenderingContext2D_fillText));
__jsb_cc_CanvasRenderingContext2D_proto->defineFunction("strokeText", _SE(js_engine_CanvasRenderingContext2D_strokeText));
__jsb_cc_CanvasRenderingContext2D_proto->defineFunction("fillRect", _SE(js_engine_CanvasRenderingContext2D_fillRect));
__jsb_cc_CanvasRenderingContext2D_proto->defineFunction("measureText", _SE(js_engine_CanvasRenderingContext2D_measureText));
se::ScriptEngine::getInstance()->clearException();
return true;
}
static bool js_engine_FileUtils_listFilesRecursively(const se::State &s) { // NOLINT(readability-identifier-naming)
auto *cobj = static_cast<cc::FileUtils *>(s.nativeThisObject());
SE_PRECONDITION2(cobj, false, "js_engine_FileUtils_listFilesRecursively : Invalid Native Object");
const auto & args = s.args();
size_t argc = args.size();
CC_UNUSED bool ok = true;
if (argc == 2) {
std::string arg0;
std::vector<std::string> arg1;
ok &= seval_to_std_string(args[0], &arg0);
SE_PRECONDITION2(ok, false, "js_engine_FileUtils_listFilesRecursively : Error processing arguments");
cobj->listFilesRecursively(arg0, &arg1);
se::Object *list = args[1].toObject();
SE_PRECONDITION2(args[1].isObject() && list->isArray(), false, "js_engine_FileUtils_listFilesRecursively : 2nd argument should be an Array");
for (uint32_t i = 0; i < static_cast<uint32_t>(arg1.size()); i++) {
list->setArrayElement(i, se::Value(arg1[i]));
}
list->setProperty("length", se::Value(static_cast<uint32_t>(arg1.size())));
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
return false;
}
SE_BIND_FUNC(js_engine_FileUtils_listFilesRecursively) // NOLINT(readability-identifier-naming)
static bool js_se_setExceptionCallback(se::State &s) { // NOLINT(readability-identifier-naming)
const auto &args = s.args();
if (args.size() != 1 || !args[0].isObject() || !args[0].toObject()->isFunction()) {
SE_REPORT_ERROR("expect 1 arguments of Function type, %d provided", (int)args.size());
return false;
}
se::Object *objFunc = args[0].toObject();
// se::Value::reset will invoke decRef() while destroying s.args()
// increase ref here
objFunc->incRef();
if (s.thisObject()) {
s.thisObject()->attachObject(objFunc); // prevent GC
} else {
//prevent GC in C++ & JS
objFunc->root();
}
se::ScriptEngine::getInstance()->setJSExceptionCallback([objFunc](const char *location, const char *message, const char *stack) {
se::AutoHandleScope scope;
se::ValueArray jsArgs;
jsArgs.resize(3);
jsArgs[0] = se::Value(location);
jsArgs[1] = se::Value(message);
jsArgs[2] = se::Value(stack);
objFunc->call(jsArgs, nullptr);
});
return true;
}
SE_BIND_FUNC(js_se_setExceptionCallback) // NOLINT(readability-identifier-naming)
static bool register_filetuils_ext(se::Object * /*obj*/) { // NOLINT(readability-identifier-naming)
__jsb_cc_FileUtils_proto->defineFunction("listFilesRecursively", _SE(js_engine_FileUtils_listFilesRecursively));
return true;
}
static bool register_se_setExceptionCallback(se::Object *obj) { // NOLINT(readability-identifier-naming)
se::Value jsb;
if (!obj->getProperty("jsb", &jsb)) {
jsb.setObject(se::Object::createPlainObject());
obj->setProperty("jsb", jsb);
}
auto *jsbObj = jsb.toObject();
jsbObj->defineFunction("onError", _SE(js_se_setExceptionCallback));
return true;
}
bool register_all_cocos_manual(se::Object *obj) {
register_plist_parser(obj);
register_sys_localStorage(obj);
register_device(obj);
register_canvas_context2d(obj);
register_filetuils_ext(obj);
register_se_setExceptionCallback(obj);
return true;
}