jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
if(arg.IsEmpty() || arg->IsNull() || arg->IsUndefined()) {
return NULL;
}
if(arg->IsArray()) {
v8::Local<v8::Array> array = v8::Array::Cast(*arg);
uint32_t arraySize = array->Length();
jclass objectClazz = env->FindClass("java/lang/Object");
jobjectArray result = env->NewObjectArray(arraySize, objectClazz, NULL);
for(uint32_t i=0; i<arraySize; i++) {
jobject val = v8ToJava(env, array->Get(i));
env->SetObjectArrayElement(result, i, val);
}
return result;
}
if(arg->IsString()) {
v8::String::Utf8Value val(arg->ToString());
return env->NewStringUTF(*val);
}
if(arg->IsInt32() || arg->IsUint32()) {
jint val = arg->ToInt32()->Value();
jclass clazz = env->FindClass("java/lang/Integer");
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(I)V");
return env->NewObject(clazz, constructor, val);
}
if(arg->IsNumber()) {
jdouble val = arg->ToNumber()->Value();
jclass clazz = env->FindClass("java/lang/Double");
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(D)V");
return env->NewObject(clazz, constructor, val);
}
if(arg->IsBoolean()) {
jboolean val = arg->ToBoolean()->Value();
jclass clazz = env->FindClass("java/lang/Boolean");
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(Z)V");
return env->NewObject(clazz, constructor, val);
}
if(arg->IsObject()) {
v8::Local<v8::Object> obj = v8::Object::Cast(*arg);
v8::Local<v8::Value> isJavaObject = obj->GetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_OBJECT));
if(!isJavaObject.IsEmpty() && isJavaObject->IsBoolean()) {
return v8ToJava_javaObject(env, obj);
}
v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_LONG));
if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) {
return v8ToJava_javaLong(env, obj);
}
}
// TODO: handle other arg types
v8::String::AsciiValue typeStr(arg);
printf("v8ToJava: Unhandled type: %s\n", *typeStr);
return NULL;
}
bool V8AbstractEventListener::shouldPreventDefault(
v8::Local<v8::Value> returnValue) {
// Prevent default action if the return value is false in accord with the spec
// http://www.w3.org/TR/html5/webappapis.html#event-handler-attributes
return returnValue->IsBoolean() && !returnValue.As<v8::Boolean>()->Value();
}
bool V8WindowErrorHandler::shouldPreventDefault(v8::Local<v8::Value> returnValue)
{
return returnValue->IsBoolean() && returnValue->BooleanValue();
}
bool V8ErrorHandler::shouldPreventDefault(v8::Local<v8::Value> returnValue) {
return returnValue->IsBoolean() && returnValue.As<v8::Boolean>()->Value();
}
void encodeValue(bson *bb, const char *name, v8::Local<v8::Value> element,
bool doJson)
{
if (element.IsEmpty() || element->IsUndefined() || element->IsFunction())
;
else if (element->IsNull())
bson_append_null(bb, name);
else if (element->IsDate())
bson_append_date(bb, name, (bson_date_t) element->NumberValue());
else if (element->IsBoolean())
bson_append_bool(bb, name, element->IsTrue());
else if (element->IsNumber() || element->IsNumberObject())
{
double value = element->NumberValue();
int64_t num = (int64_t) value;
if (value == (double) num)
{
if (num >= -2147483648ll && num <= 2147483647ll)
bson_append_int(bb, name, (int) num);
else
bson_append_long(bb, name, num);
}
else
bson_append_double(bb, name, value);
}
else if (element->IsArray())
encodeArray(bb, name, element);
else if (element->IsRegExp())
{
v8::Local<v8::RegExp> re = v8::Local<v8::RegExp>::Cast(element);
v8::Local<v8::String> src = re->GetSource();
v8::RegExp::Flags flgs = re->GetFlags();
char flgStr[4];
char *p = flgStr;
if (flgs & v8::RegExp::kIgnoreCase)
*p++ = 'i';
if (flgs & v8::RegExp::kGlobal)
*p++ = 'g';
if (flgs & v8::RegExp::kMultiline)
*p++ = 'm';
*p = 0;
bson_append_regex(bb, name, *v8::String::Utf8Value(src), flgStr);
}
else if (element->IsObject())
{
{
obj_ptr<Int64> num = (Int64 *)Int64_base::getInstance(element);
if (num)
{
if (num->m_num >= -2147483648ll && num->m_num <= 2147483647ll)
bson_append_int(bb, name, (int) num->m_num);
else
bson_append_long(bb, name, num->m_num);
return;
}
}
{
obj_ptr<Buffer_base> buf = Buffer_base::getInstance(element);
if (buf)
{
std::string strBuf;
buf->toString(strBuf);
bson_append_binary(bb, name, BSON_BIN_BINARY, strBuf.c_str(),
(int) strBuf.length());
return;
}
}
{
obj_ptr<MongoID> oid = (MongoID *) MongoID_base::getInstance(
element);
if (oid)
{
bson_append_oid(bb, name, &oid->m_id);
return;
}
}
encodeObject(bb, name, element, doJson);
}
else
{
v8::String::Utf8Value v(element);
bson_append_string(bb, name, ToCString(v));
}
}
result_t util_base::isBoolean(v8::Local<v8::Value> v, bool &retVal)
{
retVal = v->IsBoolean() || v->IsBooleanObject();
return 0;
}
// converts js value to java object and recursively converts sub objects if this
// object is a container type
jobject TypeConverter::jsValueToJavaObject(v8::Local<v8::Value> jsValue, bool *isNew)
{
JNIEnv *env = JNIScope::getEnv();
if (env == NULL) {
return NULL;
}
if (jsValue->IsNumber()) {
jdouble javaDouble = TypeConverter::jsNumberToJavaDouble(jsValue->ToNumber());
*isNew = true;
return env->NewObject(JNIUtil::doubleClass, JNIUtil::doubleInitMethod, javaDouble);
} else if (jsValue->IsBoolean()) {
jboolean javaBoolean = TypeConverter::jsBooleanToJavaBoolean(jsValue->ToBoolean());
*isNew = true;
return env->NewObject(JNIUtil::booleanClass, JNIUtil::booleanInitMethod, javaBoolean);
} else if (jsValue->IsString()) {
*isNew = true;
return TypeConverter::jsStringToJavaString(jsValue->ToString());
} else if (jsValue->IsDate()) {
Local<Date> date = Local<Date>::Cast<Value>(jsValue);
return TypeConverter::jsDateToJavaDate(date);
} else if (jsValue->IsArray()) {
*isNew = true;
return TypeConverter::jsArrayToJavaArray(v8::Handle<v8::Array>::Cast(jsValue));
} else if (jsValue->IsFunction()) {
*isNew = true;
return TypeConverter::jsObjectToJavaFunction(jsValue->ToObject());
} else if (jsValue->IsObject()) {
v8::Handle<v8::Object> jsObject = jsValue->ToObject();
if (JavaObject::isJavaObject(jsObject)) {
*isNew = JavaObject::useGlobalRefs ? false : true;
JavaObject *javaObject = JavaObject::Unwrap<JavaObject>(jsObject);
return javaObject->getJavaObject();
} else {
v8::Handle<v8::Array> objectKeys = jsObject->GetOwnPropertyNames();
int numKeys = objectKeys->Length();
*isNew = true;
jobject javaHashMap = env->NewObject(JNIUtil::hashMapClass, JNIUtil::hashMapInitMethod, numKeys);
for (int i = 0; i < numKeys; i++) {
v8::Local<v8::Value> jsObjectPropertyKey = objectKeys->Get((uint32_t) i);
bool keyIsNew, valueIsNew;
jobject javaObjectPropertyKey = TypeConverter::jsValueToJavaObject(jsObjectPropertyKey, &keyIsNew);
v8::Local<v8::Value> jsObjectPropertyValue = jsObject->Get(jsObjectPropertyKey);
jobject javaObjectPropertyValue = TypeConverter::jsValueToJavaObject(jsObjectPropertyValue, &valueIsNew);
jobject result = env->CallObjectMethod(javaHashMap,
JNIUtil::hashMapPutMethod,
javaObjectPropertyKey,
javaObjectPropertyValue);
env->DeleteLocalRef(result);
if (keyIsNew) {
env->DeleteLocalRef(javaObjectPropertyKey);
}
if (valueIsNew) {
env->DeleteLocalRef(javaObjectPropertyValue);
}
}
return javaHashMap;
}
}
LOGW(TAG, "jsValueToJavaObject returning null");
return NULL;
}