void Msg_Struct::build_buffer_arg(const Field_Info &field_info, Block_Buffer &buffer, Isolate* isolate, v8::Local<v8::Value> value) {
if(field_info.field_type == "int8") {
int8_t val = 0;
if (value->IsInt32()) {
val = value->Int32Value(isolate->GetCurrentContext()).FromJust();
}
buffer.write_int8(val);
}
else if(field_info.field_type == "int16") {
int16_t val = 0;
if (value->IsInt32()) {
val = value->Int32Value(isolate->GetCurrentContext()).FromJust();
}
buffer.write_int16(val);
}
else if(field_info.field_type == "int32") {
int32_t val = 0;
if (value->IsInt32()) {
val = value->Int32Value(isolate->GetCurrentContext()).FromJust();
}
buffer.write_int32(val);
}
else if(field_info.field_type == "int64") {
int64_t val = 0;
if (value->IsNumber()) {
val = value->NumberValue(isolate->GetCurrentContext()).FromJust();
}
buffer.write_int64(val);
}
else if(field_info.field_type == "double") {
double val = 0;
if (value->IsNumber()) {
val = value->NumberValue(isolate->GetCurrentContext()).FromJust();
}
buffer.write_double(val);
}
else if(field_info.field_type == "bool") {
bool val = 0;
if (value->IsBoolean()) {
val = value->BooleanValue(isolate->GetCurrentContext()).FromJust();
}
buffer.write_bool(val);
}
else if(field_info.field_type == "string") {
std::string val = "";
if (value->IsString()) {
String::Utf8Value str(value->ToString(isolate->GetCurrentContext()).ToLocalChecked());
std::stringstream stream;
stream << ToCString(str);
val = stream.str();
}
buffer.write_string(val);
}
else {
LOG_ERROR("Can not find the field_type:%s, struct_name:%s", field_info.field_type.c_str(), struct_name().c_str());
}
}
void convertV8ObjectToNPVariant(v8::Local<v8::Value> object, NPObject* owner, NPVariant* result)
{
VOID_TO_NPVARIANT(*result);
// It is really the caller's responsibility to deal with the empty handle case because there could be different actions to
// take in different contexts.
ASSERT(!object.IsEmpty());
if (object.IsEmpty())
return;
if (object->IsInt32())
INT32_TO_NPVARIANT(object->NumberValue(), *result);
else if (object->IsNumber())
DOUBLE_TO_NPVARIANT(object->NumberValue(), *result);
else if (object->IsBoolean())
BOOLEAN_TO_NPVARIANT(object->BooleanValue(), *result);
else if (object->IsNull())
NULL_TO_NPVARIANT(*result);
else if (object->IsUndefined())
VOID_TO_NPVARIANT(*result);
else if (object->IsString()) {
v8::String::Utf8Value utf8(object);
char* utf8_chars = strdup(*utf8);
STRINGN_TO_NPVARIANT(utf8_chars, utf8.length(), *result);
} else if (object->IsObject()) {
WebCore::DOMWindow* window = WebCore::V8Proxy::retrieveWindow(WebCore::V8Proxy::currentContext());
NPObject* npobject = npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(object), window);
if (npobject)
_NPN_RegisterObject(npobject, owner);
OBJECT_TO_NPVARIANT(npobject, *result);
}
}
std::vector<uint8_t>
JSZCluster::addArgument(v8::Local<v8::Value> value, const std::shared_ptr<ClusterCmdParamsBase> &cmdParam) {
if (value->IsUint32()) {
return cmdParam->getType().getRaw(value->ToUint32()->Value());
}
if (value->IsInt32()) {
return cmdParam->getType().getRaw(value->ToInt32()->Value());
}
if (value->IsString()) {
String::Utf8Value utf8Value(value);
return cmdParam->getType().getRaw(*utf8Value);
}
if (value->IsArray()) {
Local<Array> array = value.As<Array>();
std::vector<std::string> strArray;
for (uint32_t index = 0; index < array->Length(); index++) {
String::Utf8Value utf8Value(array->Get(index));
strArray.push_back(*utf8Value);
}
return cmdParam->getType().getRaw(strArray);
}
stringstream stream;
stream << "To " << EXECUTE_CMD_BY_ID << " it is passed an invalid argument instead of type "
<< cmdParam->getZCLDataType();
throw JSException(stream.str());
}
jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
if(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::AsciiValue 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::String::AsciiValue constructorName(obj->GetConstructorName());
if(strcmp(*constructorName, "JavaObject") == 0) {
JavaObject* javaObject = node::ObjectWrap::Unwrap<JavaObject>(obj);
return javaObject->getObject();
}
}
// TODO: handle other arg types
v8::String::AsciiValue typeStr(arg);
printf("Unhandled type: %s\n", *typeStr);
return NULL;
}
inline optional<Value> toValue(v8::Local<v8::Value> value) {
if (value->IsFalse()) {
return { false };
} else if (value->IsTrue()) {
return { true };
} else if (value->IsString()) {
return { std::string(*Nan::Utf8String(value)) };
} else if (value->IsUint32()) {
return { std::uint64_t(value->Uint32Value()) };
} else if (value->IsInt32()) {
return { std::int64_t(value->Int32Value()) };
} else if (value->IsNumber()) {
return { value->NumberValue() };
} else {
return {};
}
}
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;
}
// 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()) {
*isNew = true;
if (jsValue->IsInt32()) {
jint javaInt = TypeConverter::jsNumberToJavaInt(jsValue->ToNumber());
return env->NewObject(JNIUtil::integerClass, JNIUtil::integerInitMethod, javaInt);
}
jdouble javaDouble = TypeConverter::jsNumberToJavaDouble(jsValue->ToNumber());
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;
}
}
if (!jsValue->IsNull() && !jsValue->IsUndefined()) {
LOGW(TAG, "jsValueToJavaObject returning null.");
}
return NULL;
}
