Files
cocos4/native/cocos/scripting/js-bindings/jswrapper/v8/Object.cpp
T
2017-08-18 14:34:55 +08:00

699 lines
20 KiB
C++

#include "Object.hpp"
#ifdef SCRIPT_ENGINE_V8
#include "Utils.hpp"
#include "Class.hpp"
#include "ScriptEngine.hpp"
#include "../MappingUtils.hpp"
namespace se {
std::unordered_map<Object*, void*> __objectMap; // Currently, the value `void*` is always nullptr
namespace {
v8::Isolate* __isolate = nullptr;
}
Object::Object()
: _cls(nullptr)
, _rootCount(0)
, _privateData(nullptr)
, _finalizeCb(nullptr)
, _internalData(nullptr)
{
}
Object::~Object()
{
if (_rootCount > 0)
{
_obj.unref();
}
auto iter = __objectMap.find(this);
if (iter != __objectMap.end())
{
__objectMap.erase(iter);
}
}
/*static*/
void Object::nativeObjectFinalizeHook(void* nativeObj)
{
if (nativeObj == nullptr)
return;
auto iter = NativePtrToObjectMap::find(nativeObj);
if (iter != NativePtrToObjectMap::end())
{
Object* obj = iter->second;
if (obj->_finalizeCb != nullptr)
{
obj->_finalizeCb(nativeObj);
}
else
{
assert(obj->_getClass() != nullptr);
if (obj->_getClass()->_finalizeFunc != nullptr)
obj->_getClass()->_finalizeFunc(nativeObj);
}
obj->release();
NativePtrToObjectMap::erase(iter);
}
else
{
// assert(false);
}
}
/* static */
void Object::setIsolate(v8::Isolate* isolate)
{
__isolate = isolate;
}
/* static */
void Object::cleanup()
{
void* nativeObj = nullptr;
Object* obj = nullptr;
Class* cls = nullptr;
const auto& nativePtrToObjectMap = NativePtrToObjectMap::instance();
for (const auto& e : nativePtrToObjectMap)
{
nativeObj = e.first;
obj = e.second;
if (obj->_finalizeCb != nullptr)
{
obj->_finalizeCb(nativeObj);
}
else
{
if (obj->_getClass() != nullptr)
{
if (obj->_getClass()->_finalizeFunc != nullptr)
{
obj->_getClass()->_finalizeFunc(nativeObj);
}
}
}
// internal data should only be freed in Object::cleanup, since in other case, it is freed in ScriptEngine::privateDataFinalize
if (obj->_internalData != nullptr)
{
free(obj->_internalData);
obj->_internalData = nullptr;
}
obj->release();
}
NativePtrToObjectMap::clear();
NonRefNativePtrCreatedByCtorMap::clear();
std::vector<Object*> toReleaseObjects;
for (const auto& e : __objectMap)
{
obj = e.first;
cls = obj->_getClass();
obj->_obj.persistent().Reset();
obj->_rootCount = 0;
if (cls != nullptr && cls->_name == "__CCPrivateData")
{
toReleaseObjects.push_back(obj);
}
}
for (auto e : toReleaseObjects)
{
e->release();
}
__objectMap.clear();
__isolate = nullptr;
}
Object* Object::createPlainObject()
{
v8::Local<v8::Object> jsobj = v8::Object::New(__isolate);
Object* obj = _createJSObject(nullptr, jsobj);
return obj;
}
Object* Object::getObjectWithPtr(void* ptr)
{
Object* obj = nullptr;
auto iter = NativePtrToObjectMap::find(ptr);
if (iter != NativePtrToObjectMap::end())
{
obj = iter->second;
obj->addRef();
}
return obj;
}
Object* Object::_createJSObject(Class* cls, v8::Local<v8::Object> obj)
{
Object* ret = new Object();
if (!ret->init(cls, obj))
{
delete ret;
ret = nullptr;
}
return ret;
}
Object* Object::createObjectWithClass(Class* cls)
{
v8::Local<v8::Object> jsobj = Class::_createJSObjectWithClass(cls);
Object* obj = Object::_createJSObject(cls, jsobj);
return obj;
}
Object* Object::createArrayObject(size_t length)
{
v8::Local<v8::Array> jsobj = v8::Array::New(__isolate, (int)length);
Object* obj = Object::_createJSObject(nullptr, jsobj);
return obj;
}
Object* Object::createArrayBufferObject(void* data, size_t byteLength)
{
v8::Local<v8::ArrayBuffer> jsobj = v8::ArrayBuffer::New(__isolate, byteLength);
memcpy(jsobj->GetContents().Data(), data, byteLength);
Object* obj = Object::_createJSObject(nullptr, jsobj);
return obj;
}
Object* Object::createUint8TypedArray(uint8_t* data, size_t byteLength)
{
v8::Local<v8::ArrayBuffer> jsobj = v8::ArrayBuffer::New(__isolate, byteLength);
memcpy(jsobj->GetContents().Data(), data, byteLength);
v8::Local<v8::Uint8Array> arr = v8::Uint8Array::New(jsobj, 0, byteLength);
Object* obj = Object::_createJSObject(nullptr, arr);
return obj;
}
Object* Object::createJSONObject(const std::string& jsonStr)
{
v8::Local<v8::Context> context = __isolate->GetCurrentContext();
Value strVal(jsonStr);
v8::Local<v8::Value> jsStr;
internal::seToJsValue(__isolate, strVal, &jsStr);
v8::Local<v8::String> v8Str = v8::Local<v8::String>::Cast(jsStr);
v8::MaybeLocal<v8::Value> ret = v8::JSON::Parse(context, v8Str);
if (ret.IsEmpty())
return nullptr;
v8::Local<v8::Object> jsobj = v8::Local<v8::Object>::Cast(ret.ToLocalChecked());
return Object::_createJSObject(nullptr, jsobj);
}
bool Object::init(Class* cls, v8::Local<v8::Object> obj)
{
_cls = cls;
_obj.init(obj);
_obj.setFinalizeCallback(nativeObjectFinalizeHook);
assert(__objectMap.find(this) == __objectMap.end());
__objectMap.emplace(this, nullptr);
return true;
}
bool Object::getProperty(const char *name, Value *data)
{
assert(data != nullptr);
v8::HandleScope handle_scope(__isolate);
if (_obj.persistent().IsEmpty())
{
return false;
}
v8::MaybeLocal<v8::String> nameValue = v8::String::NewFromUtf8(__isolate, name, v8::NewStringType::kNormal);
if (nameValue.IsEmpty())
return false;
v8::Local<v8::String> nameValToLocal = nameValue.ToLocalChecked();
v8::Local<v8::Context> context = __isolate->GetCurrentContext();
v8::Maybe<bool> maybeExist = _obj.handle(__isolate)->Has(context, nameValToLocal);
if (maybeExist.IsNothing())
return false;
if (!maybeExist.FromJust())
return false;
v8::MaybeLocal<v8::Value> result = _obj.handle(__isolate)->Get(context, nameValToLocal);
if (result.IsEmpty())
return false;
internal::jsToSeValue(__isolate, result.ToLocalChecked(), data);
return true;
}
void Object::setProperty(const char *name, const Value& data)
{
v8::MaybeLocal<v8::String> nameValue = v8::String::NewFromUtf8(__isolate, name, v8::NewStringType::kNormal);
if (nameValue.IsEmpty())
return;
v8::Local<v8::Value> value;
internal::seToJsValue(__isolate, data, &value);
v8::Maybe<bool> ret = _obj.handle(__isolate)->Set(__isolate->GetCurrentContext(), nameValue.ToLocalChecked(), value);
if (ret.IsNothing())
{
LOGD("ERROR: %s, Set return nothing ...\n", __FUNCTION__);
}
}
bool Object::defineProperty(const char *name, v8::AccessorNameGetterCallback getter, v8::AccessorNameSetterCallback setter)
{
v8::MaybeLocal<v8::String> nameValue = v8::String::NewFromUtf8(__isolate, name, v8::NewStringType::kNormal);
if (nameValue.IsEmpty())
return false;
v8::Local<v8::String> nameValChecked = nameValue.ToLocalChecked();
v8::Local<v8::Name> jsName = v8::Local<v8::Name>::Cast(nameValChecked);
v8::Maybe<bool> ret = _obj.handle(__isolate)->SetAccessor(__isolate->GetCurrentContext(), jsName, getter, setter);
return ret.IsJust() && ret.FromJust();
}
bool Object::isFunction() const
{
return const_cast<Object*>(this)->_obj.handle(__isolate)->IsCallable();
}
bool Object::_isNativeFunction() const
{
if (isFunction())
{
v8::String::Utf8Value utf8(const_cast<Object*>(this)->_obj.handle(__isolate));
std::string info = *utf8;
if (info.find("[native code]") != std::string::npos)
{
return true;
}
}
return false;
}
bool Object::isTypedArray() const
{
return const_cast<Object*>(this)->_obj.handle(__isolate)->IsTypedArray();
}
bool Object::getTypedArrayData(uint8_t** ptr, size_t* length) const
{
assert(isTypedArray());
v8::Local<v8::Object> obj = const_cast<Object*>(this)->_obj.handle(__isolate);
v8::Local<v8::Uint8Array> arr = v8::Local<v8::Uint8Array>::Cast(obj);
v8::ArrayBuffer::Contents content = arr->Buffer()->GetContents();
*ptr = (uint8_t*)content.Data();
*length = content.ByteLength();
return true;
}
bool Object::isArrayBuffer() const
{
v8::Local<v8::Object> obj = const_cast<Object*>(this)->_obj.handle(__isolate);
return obj->IsArrayBuffer();
}
bool Object::getArrayBufferData(uint8_t** ptr, size_t* length) const
{
assert(isArrayBuffer());
v8::Local<v8::Object> obj = const_cast<Object*>(this)->_obj.handle(__isolate);
v8::Local<v8::ArrayBuffer> arrBuf = v8::Local<v8::ArrayBuffer>::Cast(obj);
v8::ArrayBuffer::Contents content = arrBuf->GetContents();
*ptr = (uint8_t*)content.Data();
*length = content.ByteLength();
return true;
}
void Object::setPrivateData(void* data)
{
assert(_privateData == nullptr);
assert(NativePtrToObjectMap::find(data) == NativePtrToObjectMap::end());
internal::setPrivate(__isolate, _obj, data, &_internalData);
NativePtrToObjectMap::emplace(data, this);
_privateData = data;
}
void* Object::getPrivateData() const
{
if (_privateData == nullptr)
{
const_cast<Object*>(this)->_privateData = internal::getPrivate(__isolate, const_cast<Object*>(this)->_obj.handle(__isolate));
}
return _privateData;
}
void Object::clearPrivateData()
{
if (_privateData != nullptr)
{
void* data = getPrivateData();
NativePtrToObjectMap::erase(data);
internal::clearPrivate(__isolate, _obj);
_privateData = nullptr;
}
}
v8::Local<v8::Object> Object::_getJSObject() const
{
return const_cast<Object*>(this)->_obj.handle(__isolate);
}
ObjectWrap& Object::_getWrap()
{
return _obj;
}
bool Object::call(const ValueArray& args, Object* thisObject, Value* rval/* = nullptr*/)
{
if (_obj.persistent().IsEmpty())
{
LOGD("Function object is released!\n");
return false;
}
size_t argc = 0;
std::vector<v8::Local<v8::Value>> argv;
argc = args.size();
internal::seToJsArgs(__isolate, args, &argv);
v8::Local<v8::Object> thiz = v8::Local<v8::Object>::Cast(v8::Undefined(__isolate));
if (thisObject != nullptr)
{
if (thisObject->_obj.persistent().IsEmpty())
{
LOGD("This object is released!\n");
return false;
}
thiz = thisObject->_obj.handle(__isolate);
}
for (size_t i = 0; i < argc; ++i)
{
if (argv[i].IsEmpty())
{
LOGD("%s argv[%d] is released!\n", __FUNCTION__, (int)i);
return false;
}
}
v8::Local<v8::Context> context = se::ScriptEngine::getInstance()->_getContext();
v8::MaybeLocal<v8::Value> result = _obj.handle(__isolate)->CallAsFunction(context, thiz, (int)argc, argv.data());
if (!result.IsEmpty())
{
if (rval != nullptr)
{
internal::jsToSeValue(__isolate, result.ToLocalChecked(), rval);
}
return true;
}
else
{
SE_REPORT_ERROR("Invoking function (%p) failed!", this);
se::ScriptEngine::getInstance()->clearException();
}
// assert(false);
return false;
}
bool Object::defineFunction(const char *funcName, void (*func)(const v8::FunctionCallbackInfo<v8::Value> &args))
{
v8::MaybeLocal<v8::String> maybeFuncName = v8::String::NewFromUtf8(__isolate, funcName, v8::NewStringType::kNormal);
if (maybeFuncName.IsEmpty())
return false;
v8::Local<v8::Context> context = __isolate->GetCurrentContext();
v8::MaybeLocal<v8::Function> maybeFunc = v8::FunctionTemplate::New(__isolate, func)->GetFunction(context);
if (maybeFunc.IsEmpty())
return false;
v8::Maybe<bool> ret = _obj.handle(__isolate)->Set(context,
v8::Local<v8::Name>::Cast(maybeFuncName.ToLocalChecked()),
maybeFunc.ToLocalChecked());
return ret.IsJust() && ret.FromJust();
}
bool Object::isArray() const
{
return const_cast<Object*>(this)->_obj.handle(__isolate)->IsArray();
}
bool Object::getArrayLength(uint32_t* length) const
{
assert(isArray());
assert(length != nullptr);
Object* thiz = const_cast<Object*>(this);
v8::MaybeLocal<v8::String> lengthStr = v8::String::NewFromUtf8(__isolate, "length", v8::NewStringType::kNormal);
if (lengthStr.IsEmpty())
{
*length = 0;
return false;
}
v8::Local<v8::Context> context = __isolate->GetCurrentContext();
v8::MaybeLocal<v8::Value> val = thiz->_obj.handle(__isolate)->Get(context, lengthStr.ToLocalChecked());
if (val.IsEmpty())
return false;
v8::MaybeLocal<v8::Object> obj = val.ToLocalChecked()->ToObject(context);
if (obj.IsEmpty())
return false;
v8::Maybe<uint32_t> mbLen= obj.ToLocalChecked()->Uint32Value(context);
if (mbLen.IsNothing())
return false;
*length = mbLen.FromJust();
return true;
}
bool Object::getArrayElement(uint32_t index, Value* data) const
{
assert(isArray());
assert(data != nullptr);
Object* thiz = const_cast<Object*>(this);
v8::MaybeLocal<v8::Value> result = thiz->_obj.handle(__isolate)->Get(__isolate->GetCurrentContext(), index);
if (result.IsEmpty())
return false;
internal::jsToSeValue(__isolate, result.ToLocalChecked(), data);
return true;
}
bool Object::setArrayElement(uint32_t index, const Value& data)
{
assert(isArray());
v8::Local<v8::Value> jsval;
internal::seToJsValue(__isolate, data, &jsval);
v8::Maybe<bool> ret = _obj.handle(__isolate)->Set(__isolate->GetCurrentContext(), index, jsval);
return ret.IsJust() && ret.FromJust();
}
// void Object::getAsFloat32Array(float **ptr, unsigned int *length) {
// float *pt;
// unsigned int len;
//
// v8::Local<v8::Value> value = _obj.handle(__isolate);
//
// v8::Local<v8::Float32Array> myarr = _obj.handle(__isolate).As<v8::Float32Array>();
// len = myarr->Length();
// pt = (float *) ((char *) myarr->Buffer()->GetContents().Data() + myarr->ByteOffset());
//
// *length = len;
// *ptr = pt;
// }
//
// void Object::getAsUint8Array(unsigned char **ptr, unsigned int *length) {
// unsigned char *pt;
// unsigned int len;
//
// v8::Local<v8::Value> value = _obj.handle(__isolate);
//
// v8::Local<v8::Uint8Array> myarr = _obj.handle(__isolate).As<v8::Uint8Array>();
//
// len = myarr->Length();
// pt = (unsigned char *) myarr->Buffer()->GetContents().Data() + myarr->ByteOffset();
//
// *length = len;
// *ptr = pt;
// }
//
// void Object::getAsUint16Array(unsigned short **ptr, unsigned int *length) {
// unsigned short *pt;
// unsigned int len;
//
// v8::Local<v8::Value> value = _obj.handle(__isolate);
//
// v8::Local<v8::Uint16Array> myarr = _obj.handle(__isolate).As<v8::Uint16Array>();
//
// len = myarr->Length();
// pt = (unsigned short *) myarr->Buffer()->GetContents().Data();
//
// *length = len;
// *ptr = pt;
// }
//
// void Object::getAsUint32Array(unsigned int **ptr, unsigned int *length) {
// unsigned int *pt;
// unsigned int len;
//
// v8::Local<v8::Value> value = _obj.handle(__isolate);
//
// v8::Local<v8::Uint32Array> myarr = _obj.handle(__isolate).As<v8::Uint32Array>();
//
// len = myarr->Length();
//
// //ArrayBuffer::Contents float_c=pt=myarr->Buffer()->GetContents();
// pt = (unsigned int *) myarr->Buffer()->GetContents().Data();
//
// *length = len;
// *ptr = pt;
// }
bool Object::getAllKeys(std::vector<std::string>* allKeys) const
{
assert(allKeys != nullptr);
Object* thiz = const_cast<Object*>(this);
v8::Local<v8::Context> context = __isolate->GetCurrentContext();
v8::MaybeLocal<v8::Array> keys = thiz->_obj.handle(__isolate)->GetOwnPropertyNames(context);
if (keys.IsEmpty())
return false;
v8::Local<v8::Array> keysChecked = keys.ToLocalChecked();
Value keyVal;
for (uint32_t i = 0, len = keysChecked->Length(); i < len; ++i)
{
v8::MaybeLocal<v8::Value> key = keysChecked->Get(context, i);
if (key.IsEmpty())
{
allKeys->clear();
return false;
}
internal::jsToSeValue(__isolate, key.ToLocalChecked(), &keyVal);
if (keyVal.isString())
{
allKeys->push_back(keyVal.toString());
}
else if (keyVal.isNumber())
{
char buf[50] = {0};
snprintf(buf, sizeof(buf), "%d", keyVal.toInt32());
allKeys->push_back(buf);
}
else
{
assert(false);
}
}
return true;
}
Class* Object::_getClass() const
{
return _cls;
}
void Object::_setFinalizeCallback(V8FinalizeFunc finalizeCb)
{
assert(finalizeCb != nullptr);
_finalizeCb = finalizeCb;
}
void Object::root()
{
if (_rootCount == 0)
{
_obj.ref();
}
++_rootCount;
}
void Object::unroot()
{
if (_rootCount > 0)
{
--_rootCount;
if (_rootCount == 0)
{
_obj.unref();
}
}
}
bool Object::isRooted() const
{
return _rootCount > 0;
}
bool Object::isSame(Object *o) const
{
Object* a = const_cast<Object*>(this);
return a->_obj.handle(__isolate) == o->_obj.handle(__isolate);
}
bool Object::attachChild(Object *child)
{
assert(child);
Object* global = ScriptEngine::getInstance()->getGlobalObject();
Value jsbVal;
if (!global->getProperty("jsb", &jsbVal))
return false;
Object* jsbObj = jsbVal.toObject();
Value func;
if (!jsbObj->getProperty("registerNativeRef", &func))
return false;
ValueArray args;
args.push_back(Value(this));
args.push_back(Value(child));
func.toObject()->call(args, global);
return true;
}
bool Object::detachChild(Object *child)
{
assert(child);
Object* global = ScriptEngine::getInstance()->getGlobalObject();
Value jsbVal;
if (!global->getProperty("jsb", &jsbVal))
return false;
Object* jsbObj = jsbVal.toObject();
Value func;
if (!jsbObj->getProperty("unregisterNativeRef", &func))
return false;
ValueArray args;
args.push_back(Value(this));
args.push_back(Value(child));
func.toObject()->call(args, global);
return true;
}
} // namespace se {
#endif // SCRIPT_ENGINE_V8