Files
cocos4/native/cocos/scripting/js-bindings/jswrapper/jsc/Object.cpp
T
2017-08-02 14:37:41 +08:00

598 lines
16 KiB
C++

#include "Object.hpp"
#ifdef SCRIPT_ENGINE_JSC
#include "Utils.hpp"
#include "Class.hpp"
#include "ScriptEngine.hpp"
namespace se {
std::unordered_map<void* /*native*/, Object* /*jsobj*/> __nativePtrToObjectMap;
std::unordered_map<void* /*native*/, bool> __nonRefNativeObjectCreatedByCtorMap;
namespace {
JSContextRef __cx = nullptr;
}
Object::Object()
: _cls(nullptr)
, _obj(nullptr)
, _rootCount(0)
, _hasPrivateData(false)
, _isCleanup(false)
, _finalizeCb(nullptr)
{
}
Object::~Object()
{
_cleanup();
}
Object* Object::createPlainObject()
{
Object* obj = _createJSObject(nullptr, JSObjectMake(__cx, nullptr, nullptr));
return obj;
}
Object* Object::createArrayObject(size_t length)
{
JSValueRef exception = nullptr;
JSObjectRef jsObj = JSObjectMakeArray(__cx, 0, nullptr, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return nullptr;
}
Object* obj = _createJSObject(nullptr, jsObj);
return obj;
}
static void myJSTypedArrayBytesDeallocator(void* bytes, void* deallocatorContext)
{
free(bytes);
}
Object* Object::createArrayBufferObject(void* data, size_t byteLength)
{
void* copiedData = malloc(byteLength);
memcpy(copiedData, data, byteLength);
JSValueRef exception = nullptr;
JSObjectRef jsobj = JSObjectMakeArrayBufferWithBytesNoCopy(__cx, copiedData, byteLength, myJSTypedArrayBytesDeallocator, nullptr, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return nullptr;
}
Object* obj = Object::_createJSObject(nullptr, jsobj);
return obj;
}
Object* Object::createUint8TypedArray(uint8_t* data, size_t byteLength)
{
void* copiedData = malloc(byteLength);
memcpy(copiedData, data, byteLength);
JSValueRef exception = nullptr;
JSObjectRef jsobj = JSObjectMakeTypedArrayWithBytesNoCopy(__cx, kJSTypedArrayTypeUint8Array, copiedData, byteLength, myJSTypedArrayBytesDeallocator, nullptr, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return nullptr;
}
Object* obj = Object::_createJSObject(nullptr, jsobj);
return obj;
}
Object* Object::createJSONObject(const std::string& jsonStr)
{
Object* obj = nullptr;
JSStringRef jsStr = JSStringCreateWithUTF8CString(jsonStr.c_str());
JSValueRef ret = JSValueMakeFromJSONString(__cx, jsStr);
if (ret != nullptr)
{
JSValueRef exception = nullptr;
JSObjectRef jsobj = JSValueToObject(__cx, ret, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return nullptr;
}
obj = Object::_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::createObjectWithClass(Class* cls)
{
JSObjectRef jsobj = Class::_createJSObjectWithClass(cls);
Object* obj = Object::_createJSObject(cls, jsobj);
return obj;
}
Object* Object::_createJSObject(Class* cls, JSObjectRef obj)
{
Object* ret = new Object();
if (!ret->init(obj))
{
delete ret;
ret = nullptr;
}
ret->_cls = cls;
return ret;
}
bool Object::init(JSObjectRef obj)
{
_obj = obj;
return true;
}
void Object::_cleanup(void* nativeObj/* = nullptr*/)
{
if (_isCleanup)
return;
if (_hasPrivateData)
{
if (nativeObj == nullptr)
{
nativeObj = internal::getPrivate(_obj);
}
if (nativeObj != nullptr)
{
auto iter = __nativePtrToObjectMap.find(nativeObj);
if (iter != __nativePtrToObjectMap.end())
{
__nativePtrToObjectMap.erase(iter);
}
}
else
{
assert(false);
}
}
if (_rootCount > 0)
{
// printf("Object::_cleanup, (%p) rootCount: %u\n", this, _rootCount);
// Don't unprotect if it's in cleanup, otherwise, it will trigger crash.
if (!ScriptEngine::getInstance()->_isInCleanup)
JSValueUnprotect(__cx, _obj);
}
_isCleanup = true;
}
void Object::_setFinalizeCallback(JSObjectFinalizeCallback finalizeCb)
{
_finalizeCb = finalizeCb;
}
bool Object::getProperty(const char* name, Value* data)
{
assert(data != nullptr);
JSStringRef jsName = JSStringCreateWithUTF8CString(name);
bool exist = JSObjectHasProperty(__cx, _obj, jsName);
if (exist)
{
JSValueRef exception = nullptr;
JSValueRef jsValue = JSObjectGetProperty(__cx, _obj, jsName, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
internal::jsToSeValue(__cx, jsValue, data);
}
JSStringRelease(jsName);
return exist;
}
void Object::setProperty(const char* name, const Value& v)
{
JSStringRef jsName = JSStringCreateWithUTF8CString(name);
JSValueRef jsValue = nullptr;
JSObjectRef obj = _obj;
if (v.getType() == Value::Type::Number)
{
jsValue = JSValueMakeNumber(__cx, v.toNumber());
}
else if (v.getType() == Value::Type::String)
{
JSStringRef jsstr = JSStringCreateWithUTF8CString(v.toString().c_str());
jsValue = JSValueMakeString(__cx, jsstr);
JSStringRelease(jsstr);
}
else if (v.getType() == Value::Type::Boolean)
{
jsValue = JSValueMakeBoolean(__cx, v.toBoolean());
}
else if (v.getType() == Value::Type::Object)
{
jsValue = v.toObject()->_obj;
}
else if (v.getType() == Value::Type::Null)
{
jsValue = JSValueMakeNull(__cx);
}
else
{
jsValue = JSValueMakeUndefined(__cx);
}
JSValueRef exception = nullptr;
JSObjectSetProperty(__cx, obj, jsName, jsValue, kJSPropertyAttributeNone, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
}
JSStringRelease(jsName);
}
bool Object::defineProperty(const char *name, JSObjectCallAsFunctionCallback getter, JSObjectCallAsFunctionCallback setter)
{
return internal::defineProperty(this, name, getter, setter);
}
bool Object::call(const ValueArray& args, Object* thisObject, Value* rval/* = nullptr*/)
{
assert(isFunction());
JSObjectRef contextObject = nullptr;
if (thisObject != nullptr)
{
contextObject = thisObject->_obj;
}
JSValueRef* jsArgs = nullptr;
if (!args.empty())
{
jsArgs = (JSValueRef*)malloc(sizeof(JSValueRef) * args.size());
internal::seToJsArgs(__cx, args, jsArgs);
}
JSValueRef exception = nullptr;
JSValueRef rcValue = JSObjectCallAsFunction(__cx, _obj, contextObject, args.size(), jsArgs, &exception);
free(jsArgs);
if (rcValue != nullptr)
{
if (rval != nullptr && !JSValueIsUndefined(__cx, rcValue))
{
internal::jsToSeValue(__cx, rcValue, rval);
}
return true;
}
// Function call failed, try to output exception
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
}
return false;
}
bool Object::defineFunction(const char* funcName, JSObjectCallAsFunctionCallback func)
{
JSStringRef jsName = JSStringCreateWithUTF8CString(funcName);
JSObjectRef jsFunc = JSObjectMakeFunctionWithCallback(__cx, jsName, func);
JSValueRef exception = nullptr;
JSObjectSetProperty(__cx, _obj, jsName, jsFunc, kJSPropertyAttributeNone, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
}
JSStringRelease(jsName);
return true;
}
bool Object::getArrayLength(uint32_t* length) const
{
assert(isArray());
assert(length != nullptr);
JSStringRef key = JSStringCreateWithUTF8CString("length");
JSValueRef exception = nullptr;
JSValueRef v = JSObjectGetProperty(__cx, _obj, key, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
JSStringRelease(key);
*length = 0;
return false;
}
assert(JSValueIsNumber(__cx, v));
double len = JSValueToNumber(__cx, v, nullptr);
JSStringRelease(key);
*length = (uint32_t)len;
return true;
}
bool Object::getArrayElement(uint32_t index, Value* data) const
{
assert(isArray());
assert(data != nullptr);
JSValueRef exception = nullptr;
JSValueRef v = JSObjectGetPropertyAtIndex(__cx, _obj, index, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
internal::jsToSeValue(__cx, v, data);
return true;
}
bool Object::setArrayElement(uint32_t index, const Value& data)
{
assert(isArray());
JSValueRef v;
internal::seToJsValue(__cx, data, &v);
JSValueRef exception = nullptr;
JSObjectSetPropertyAtIndex(__cx, _obj, index, v, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
return true;
}
bool Object::getAllKeys(std::vector<std::string>* allKeys) const
{
JSPropertyNameArrayRef keys = JSObjectCopyPropertyNames(__cx, _obj);
size_t expectedCount = JSPropertyNameArrayGetCount(keys);
std::string tmp;
for (size_t count = 0; count < expectedCount; ++count)
{
JSStringRef key = JSPropertyNameArrayGetNameAtIndex(keys, count);
internal::jsStringToStdString(__cx, key, &tmp);
allKeys->push_back(tmp);
}
JSPropertyNameArrayRelease(keys);
return true;
}
bool Object::isFunction() const
{
return JSObjectIsFunction(__cx, _obj);
}
bool Object::isTypedArray() const
{
JSTypedArrayType type = JSValueGetTypedArrayType(__cx, _obj, nullptr);
return type != kJSTypedArrayTypeNone && type != kJSTypedArrayTypeArrayBuffer;
}
bool Object::getTypedArrayData(uint8_t** ptr, size_t* length) const
{
assert(isTypedArray());
JSValueRef exception = nullptr;
*length = JSObjectGetTypedArrayByteLength(__cx, _obj, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
*ptr = (uint8_t*)JSObjectGetTypedArrayBytesPtr(__cx, _obj, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
return (*ptr != nullptr);
}
bool Object::_isNativeFunction() const
{
if (isFunction())
{
std::string info;
internal::forceConvertJsValueToStdString(__cx, _obj, &info);
if (info.find("[native code]") != std::string::npos)
{
return true;
}
}
return false;
}
bool Object::isArray() const
{
return JSValueIsArray(__cx, _obj);
}
bool Object::isArrayBuffer() const
{
JSValueRef exception = nullptr;
JSTypedArrayType type = JSValueGetTypedArrayType(__cx, _obj, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
return type == kJSTypedArrayTypeArrayBuffer;
}
bool Object::getArrayBufferData(uint8_t** ptr, size_t* length) const
{
assert(ptr && length);
assert(isArrayBuffer());
JSValueRef exception = nullptr;
*length = JSObjectGetArrayBufferByteLength(__cx, _obj, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
*ptr = (uint8_t*)JSObjectGetArrayBufferBytesPtr(__cx, _obj, &exception);
if (exception != nullptr)
{
ScriptEngine::getInstance()->_clearException(exception);
return false;
}
return (*ptr != nullptr);
}
void* Object::getPrivateData()
{
return internal::getPrivate(_obj);
}
void Object::setPrivateData(void *data)
{
assert(!_hasPrivateData);
assert(__nativePtrToObjectMap.find(data) == __nativePtrToObjectMap.end());
internal::setPrivate(_obj, data, _finalizeCb);
__nativePtrToObjectMap.emplace(data, this);
_hasPrivateData = true;
}
void Object::clearPrivateData()
{
if (_hasPrivateData)
{
void* data = getPrivateData();
__nativePtrToObjectMap.erase(data);
internal::clearPrivate(_obj);
_hasPrivateData = false;
}
}
void Object::setContext(JSContextRef cx)
{
__cx = cx;
}
void Object::cleanup()
{
ScriptEngine::getInstance()->addAfterCleanupHook([](){
__nativePtrToObjectMap.clear();
__nonRefNativeObjectCreatedByCtorMap.clear();
__cx = nullptr;
});
}
JSObjectRef Object::_getJSObject() const
{
return _obj;
}
Class* Object::_getClass() const
{
return _cls;
}
void Object::root()
{
if (_rootCount == 0)
{
JSValueProtect(__cx, _obj);
}
++_rootCount;
}
void Object::unroot()
{
if (_rootCount > 0)
{
--_rootCount;
if (_rootCount == 0)
{
JSValueUnprotect(__cx, _obj);
}
}
}
bool Object::isRooted() const
{
return _rootCount > 0;
}
bool Object::isSame(Object* o) const
{
return JSValueIsStrictEqual(__cx, _obj, o->_obj);
}
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_JSC