bool JavaNPObject_GetProperty(NPObject* obj, NPIdentifier identifier, NPVariant* result) {
VOID_TO_NPVARIANT(*result);
JavaInstance* instance = ExtractJavaInstance(obj);
if (instance == 0)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (name == 0)
return false;
JavaField* field = instance->getClass()->fieldNamed(name);
free(name); // TODO: use NPN_MemFree
if (field == 0) {
return false;
}
jobject local_ref = instance->getLocalRef();
jvalue value = getJNIField(local_ref,
field->getJNIType(),
field->name(),
field->type());
getJNIEnv()->DeleteLocalRef(local_ref);
convertJValueToNPVariant(value, field->getJNIType(), field->type(), result);
return true;
}
bool JavaNPObject_HasProperty(NPObject* obj, NPIdentifier identifier) {
JavaInstance* instance = ExtractJavaInstance(obj);
if (instance == 0)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (name == 0)
return false;
bool result = instance->getClass()->fieldNamed(name) != 0;
free(name);
return result;
}
bool JavaNPObject_HasMethod(NPObject* obj, NPIdentifier identifier) {
JavaInstance* instance = ExtractJavaInstance(obj);
if (instance == 0)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (name == 0)
return false;
bool result = (instance->getClass()->methodsNamed(name).size() > 0);
// TODO: use NPN_MemFree
free(name);
return result;
}
bool JavaNPObject_Invoke(NPObject* obj, NPIdentifier identifier,
const NPVariant* args, uint32_t argCount, NPVariant* result) {
JavaInstance* instance = ExtractJavaInstance(obj);
if (instance == 0)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (name == 0)
return false;
bool r = instance->invokeMethod(name, args, argCount, result);
// TODO: use NPN_MemFree
free(name);
return r;
}
bool JavaNPObjectInvoke(NPObject* obj, NPIdentifier identifier, const NPVariant* args, uint32_t argCount, NPVariant* result)
{
JavaInstance* instance = ExtractJavaInstance(obj);
if (!instance)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (!name)
return false;
instance->begin();
MethodList methodList = instance->getClass()->methodsNamed(name);
// TODO: use NPN_MemFree
free(name);
// Try to find a good match for the overloaded method. The
// fundamental problem is that JavaScript doesn't have the
// notion of method overloading and Java does. We could
// get a bit more sophisticated and attempt to do some
// type checking as well as checking the number of parameters.
size_t numMethods = methodList.size();
JavaMethod* aMethod;
JavaMethod* jMethod = 0;
for (size_t methodIndex = 0; methodIndex < numMethods; methodIndex++) {
aMethod = methodList[methodIndex];
if (aMethod->numParameters() == static_cast<int>(argCount)) {
jMethod = aMethod;
break;
}
}
if (!jMethod)
return false;
JavaValue* jArgs = new JavaValue[argCount];
for (unsigned int i = 0; i < argCount; i++)
jArgs[i] = convertNPVariantToJavaValue(args[i], jMethod->parameterAt(i));
JavaValue jResult = instance->invokeMethod(jMethod, jArgs);
instance->end();
delete[] jArgs;
VOID_TO_NPVARIANT(*result);
convertJavaValueToNPVariant(jResult, result);
return true;
}
bool JavaNPObjectGetProperty(NPObject* obj, NPIdentifier identifier, NPVariant* result)
{
VOID_TO_NPVARIANT(*result);
JavaInstance* instance = ExtractJavaInstance(obj);
if (!instance)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (!name)
return false;
instance->begin();
JavaField* field = instance->getClass()->fieldNamed(name);
free(name); // TODO: use NPN_MemFree
if (!field) {
instance->end();
return false;
}
#if PLATFORM(ANDROID)
// JSC does not seem to support returning object properties so we emulate that
// behaviour here.
JavaValue value;
#else
JavaValue value = instance->getField(field);
#endif // PLATFORM(ANDROID)
instance->end();
convertJavaValueToNPVariant(value, result);
return true;
}
bool JavaNPObjectGetProperty(NPObject* obj, NPIdentifier identifier, NPVariant* result)
{
VOID_TO_NPVARIANT(*result);
JavaInstance* instance = ExtractJavaInstance(obj);
if (!instance)
return false;
NPUTF8* name = _NPN_UTF8FromIdentifier(identifier);
if (!name)
return false;
instance->begin();
JavaField* field = instance->getClass()->fieldNamed(name);
free(name); // TODO: use NPN_MemFree
if (!field)
return false;
JavaValue value = instance->getField(field);
instance->end();
convertJavaValueToNPVariant(value, result);
return true;
}
jvalue convertValueToJValue(ExecState* exec, RootObject* rootObject, JSValue value, JavaType javaType, const char* javaClassName)
{
JSLock lock(SilenceAssertionsOnly);
jvalue result;
memset(&result, 0, sizeof(jvalue));
switch (javaType) {
case JavaTypeArray:
case JavaTypeObject:
{
// FIXME: JavaJSObject::convertValueToJObject functionality is almost exactly the same,
// these functions should use common code.
if (value.isObject()) {
JSObject* object = asObject(value);
if (object->inherits(&JavaRuntimeObject::s_info)) {
// Unwrap a Java instance.
JavaRuntimeObject* runtimeObject = static_cast<JavaRuntimeObject*>(object);
JavaInstance* instance = runtimeObject->getInternalJavaInstance();
if (instance)
result.l = instance->javaInstance();
} else if (object->classInfo() == &RuntimeArray::s_info) {
// Input is a JavaScript Array that was originally created from a Java Array
RuntimeArray* imp = static_cast<RuntimeArray*>(object);
JavaArray* array = static_cast<JavaArray*>(imp->getConcreteArray());
result.l = array->javaArray();
} else if (object->classInfo() == &JSArray::s_info) {
// Input is a Javascript Array. We need to create it to a Java Array.
result.l = convertArrayInstanceToJavaArray(exec, asArray(value), javaClassName);
} else if ((!result.l && (!strcmp(javaClassName, "java.lang.Object")))
|| (!strcmp(javaClassName, "netscape.javascript.JSObject"))) {
// Wrap objects in JSObject instances.
JNIEnv* env = getJNIEnv();
jclass jsObjectClass = env->FindClass("sun/plugin/javascript/webkit/JSObject");
jmethodID constructorID = env->GetMethodID(jsObjectClass, "<init>", "(J)V");
if (constructorID) {
jlong nativeHandle = ptr_to_jlong(object);
rootObject->gcProtect(object);
result.l = env->NewObject(jsObjectClass, constructorID, nativeHandle);
}
}
}
// Create an appropriate Java object if target type is java.lang.Object.
if (!result.l && !strcmp(javaClassName, "java.lang.Object")) {
if (value.isString()) {
UString stringValue = asString(value)->value(exec);
JNIEnv* env = getJNIEnv();
jobject javaString = env->functions->NewString(env, (const jchar*)stringValue.characters(), stringValue.length());
result.l = javaString;
} else if (value.isNumber()) {
double doubleValue = value.asNumber();
JNIEnv* env = getJNIEnv();
jclass clazz = env->FindClass("java/lang/Double");
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(D)V");
jobject javaDouble = env->functions->NewObject(env, clazz, constructor, doubleValue);
result.l = javaDouble;
} else if (value.isBoolean()) {
bool boolValue = value.asBoolean();
JNIEnv* env = getJNIEnv();
jclass clazz = env->FindClass("java/lang/Boolean");
jmethodID constructor = env->GetMethodID(clazz, "<init>", "(Z)V");
jobject javaBoolean = env->functions->NewObject(env, clazz, constructor, boolValue);
result.l = javaBoolean;
} else if (value.isUndefined()) {
UString stringValue = "undefined";
JNIEnv* env = getJNIEnv();
jobject javaString = env->functions->NewString(env, (const jchar*)stringValue.characters(), stringValue.length());
result.l = javaString;
}
}
// Convert value to a string if the target type is a java.lang.String, and we're not
// converting from a null.
if (!result.l && !strcmp(javaClassName, "java.lang.String")) {
if (!value.isNull()) {
UString stringValue = value.toString(exec);
JNIEnv* env = getJNIEnv();
jobject javaString = env->functions->NewString(env, (const jchar*)stringValue.characters(), stringValue.length());
result.l = javaString;
}
}
}
break;
case JavaTypeBoolean:
{
result.z = (jboolean)value.toNumber(exec);
}
break;
case JavaTypeByte:
{
result.b = (jbyte)value.toNumber(exec);
}
break;
case JavaTypeChar:
{
result.c = (jchar)value.toNumber(exec);
}
break;
case JavaTypeShort:
{
result.s = (jshort)value.toNumber(exec);
}
break;
case JavaTypeInt:
{
result.i = (jint)value.toNumber(exec);
}
break;
case JavaTypeLong:
{
result.j = (jlong)value.toNumber(exec);
}
break;
case JavaTypeFloat:
{
result.f = (jfloat)value.toNumber(exec);
}
break;
case JavaTypeDouble:
{
result.d = (jdouble)value.toNumber(exec);
}
break;
case JavaTypeInvalid:
case JavaTypeVoid:
break;
}
return result;
}
jvalue convertValueToJValue(ExecState* exec, JSValue value, JNIType jniType, const char* javaClassName)
{
JSLock lock(SilenceAssertionsOnly);
jvalue result;
switch (jniType) {
case array_type:
case object_type:
{
result.l = (jobject)0;
// First see if we have a Java instance.
if (value.isObject()) {
JSObject* objectImp = asObject(value);
if (objectImp->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(objectImp);
JavaInstance* instance = static_cast<JavaInstance*>(imp->getInternalInstance());
if (instance)
result.l = instance->javaInstance();
} else if (objectImp->classInfo() == &RuntimeArray::s_info) {
// Input is a JavaScript Array that was originally created from a Java Array
RuntimeArray* imp = static_cast<RuntimeArray*>(objectImp);
JavaArray* array = static_cast<JavaArray*>(imp->getConcreteArray());
result.l = array->javaArray();
} else if (objectImp->classInfo() == &JSArray::info) {
// Input is a Javascript Array. We need to create it to a Java Array.
result.l = convertArrayInstanceToJavaArray(exec, asArray(value), javaClassName);
}
}
// Now convert value to a string if the target type is a java.lang.string, and we're not
// converting from a Null.
if (!result.l && !strcmp(javaClassName, "java.lang.String")) {
#ifdef CONVERT_NULL_TO_EMPTY_STRING
if (value->isNull()) {
JNIEnv* env = getJNIEnv();
jchar buf[2];
jobject javaString = env->functions->NewString(env, buf, 0);
result.l = javaString;
} else
#else
if (!value.isNull())
#endif
{
UString stringValue = value.toString(exec);
JNIEnv* env = getJNIEnv();
jobject javaString = env->functions->NewString(env, (const jchar *)stringValue.data(), stringValue.size());
result.l = javaString;
}
} else if (!result.l)
// ANDROID
memset(&result, 0, sizeof(jvalue)); // Handle it the same as a void case
}
break;
case boolean_type:
{
result.z = (jboolean)value.toNumber(exec);
}
break;
case byte_type:
{
result.b = (jbyte)value.toNumber(exec);
}
break;
case char_type:
{
result.c = (jchar)value.toNumber(exec);
}
break;
case short_type:
{
result.s = (jshort)value.toNumber(exec);
}
break;
case int_type:
{
result.i = (jint)value.toNumber(exec);
}
break;
case long_type:
{
result.j = (jlong)value.toNumber(exec);
}
break;
case float_type:
{
result.f = (jfloat)value.toNumber(exec);
}
break;
case double_type:
{
result.d = (jdouble)value.toNumber(exec);
}
break;
break;
case invalid_type:
default:
case void_type:
{
// ANDROID
memset(&result, 0, sizeof(jvalue));
}
break;
}
return result;
}
jvalue KJS::Bindings::convertValueToJValue (KJS::ExecState *exec, KJS::Value value, JNIType _JNIType, const char *javaClassName)
{
jvalue result;
double d = 0;
d = value.toNumber(exec);
switch (_JNIType){
case object_type: {
result.l = (jobject)0;
// First see if we have a Java instance.
if (value.type() == KJS::ObjectType){
KJS::ObjectImp *objectImp = static_cast<KJS::ObjectImp*>(value.imp());
if (strcmp(objectImp->classInfo()->className, "RuntimeObject") == 0) {
KJS::RuntimeObjectImp *imp = static_cast<KJS::RuntimeObjectImp *>(value.imp());
JavaInstance *instance = static_cast<JavaInstance*>(imp->getInternalInstance());
result.l = instance->javaInstance();
}
else if (strcmp(objectImp->classInfo()->className, "RuntimeArray") == 0) {
KJS::RuntimeArrayImp *imp = static_cast<KJS::RuntimeArrayImp *>(value.imp());
JavaArray *array = static_cast<JavaArray*>(imp->getConcreteArray());
result.l = array->javaArray();
}
}
// Now convert value to a string if the target type is a java.lang.string.
if (result.l == 0 && strcmp(javaClassName, "java.lang.String") == 0) {
KJS::UString stringValue = value.toString(exec);
JNIEnv *env = getJNIEnv();
jobject javaString = env->functions->NewString (env, (const jchar *)stringValue.data(), stringValue.size());
result.l = javaString;
}
}
break;
case boolean_type: {
result.z = (jboolean)d;
}
break;
case byte_type: {
result.b = (jbyte)d;
}
break;
case char_type: {
result.c = (jchar)d;
}
break;
case short_type: {
result.s = (jshort)d;
}
break;
case int_type: {
result.i = (jint)d;
}
break;
case long_type: {
result.j = (jlong)d;
}
break;
case float_type: {
result.f = (jfloat)d;
}
break;
case double_type: {
result.d = (jdouble)d;
}
break;
break;
case invalid_type:
default:
case void_type: {
//bzero (&result, sizeof(jvalue));
memset(&result, 0, sizeof(jvalue));
}
break;
}
return result;
}