Reviewed by Jon.
[WebKit-https.git] / WebCore / bridge / jni / jni_instance.cpp
1 /*
2  * Copyright (C) 2003 Apple Computer, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25 #include "config.h"
26
27 #include "jni_class.h"
28 #include "jni_instance.h"
29 #include "jni_runtime.h"
30 #include "jni_utility.h"
31 #include "runtime_object.h"
32 #include "runtime_root.h"
33
34 #ifdef NDEBUG
35 #define JS_LOG(formatAndArgs...) ((void)0)
36 #else
37 #define JS_LOG(formatAndArgs...) { \
38     fprintf (stderr, "%s:%d -- %s:  ", __FILE__, __LINE__, __FUNCTION__); \
39     fprintf(stderr, formatAndArgs); \
40 }
41 #endif
42  
43 using namespace KJS::Bindings;
44 using namespace KJS;
45
46 JavaInstance::JavaInstance (jobject instance, PassRefPtr<RootObject> rootObject)
47     : Instance(rootObject)
48 {
49     _instance = new JObjectWrapper (instance);
50     _class = 0;
51 }
52
53 JavaInstance::~JavaInstance () 
54 {
55     delete _class; 
56 }
57
58 #define NUM_LOCAL_REFS 64
59
60 void JavaInstance::begin()
61 {
62     getJNIEnv()->PushLocalFrame (NUM_LOCAL_REFS);
63 }
64
65 void JavaInstance::end()
66 {
67     getJNIEnv()->PopLocalFrame (NULL);
68 }
69
70 Class *JavaInstance::getClass() const 
71 {
72     if (_class == 0)
73         _class = new JavaClass (_instance->_instance);
74     return _class;
75 }
76
77 JSValue *JavaInstance::stringValue() const
78 {
79     JSLock lock;
80     
81     jstring stringValue = (jstring)callJNIMethod<jobject>(_instance->_instance, "toString", "()Ljava/lang/String;");
82     JNIEnv *env = getJNIEnv();
83     const jchar *c = getUCharactersFromJStringInEnv(env, stringValue);
84     UString u((const UChar *)c, (int)env->GetStringLength(stringValue));
85     releaseUCharactersForJStringInEnv(env, stringValue, c);
86     return jsString(u);
87 }
88
89 JSValue *JavaInstance::numberValue() const
90 {
91     jdouble doubleValue = callJNIMethod<jdouble>(_instance->_instance, "doubleValue", "()D");
92     return jsNumber(doubleValue);
93 }
94
95 JSValue *JavaInstance::booleanValue() const
96 {
97     jboolean booleanValue = callJNIMethod<jboolean>(_instance->_instance, "booleanValue", "()Z");
98     return jsBoolean(booleanValue);
99 }
100
101 JSValue *JavaInstance::invokeMethod (ExecState *exec, const MethodList &methodList, const List &args)
102 {
103     int i, count = args.size();
104     jvalue *jArgs;
105     JSValue *resultValue;
106     Method *method = 0;
107     size_t numMethods = methodList.size();
108     
109     // Try to find a good match for the overloaded method.  The 
110     // fundamental problem is that JavaScript doesn have the
111     // notion of method overloading and Java does.  We could 
112     // get a bit more sophisticated and attempt to does some
113     // type checking as we as checking the number of parameters.
114     Method *aMethod;
115     for (size_t methodIndex = 0; methodIndex < numMethods; methodIndex++) {
116         aMethod = methodList[methodIndex];
117         if (aMethod->numParameters() == count) {
118             method = aMethod;
119             break;
120         }
121     }
122     if (method == 0) {
123         JS_LOG ("unable to find an appropiate method\n");
124         return jsUndefined();
125     }
126     
127     const JavaMethod *jMethod = static_cast<const JavaMethod*>(method);
128     JS_LOG ("call %s %s on %p\n", method->name(), jMethod->signature(), _instance->_instance);
129     
130     if (count > 0) {
131         jArgs = (jvalue *)malloc (count * sizeof(jvalue));
132     }
133     else
134         jArgs = 0;
135         
136     for (i = 0; i < count; i++) {
137         JavaParameter* aParameter = jMethod->parameterAt(i);
138         jArgs[i] = convertValueToJValue (exec, args.at(i), aParameter->getJNIType(), aParameter->type());
139         JS_LOG("arg[%d] = %s\n", i, args.at(i)->toString(exec).ascii());
140     }
141         
142     jvalue result;
143
144     // Try to use the JNI abstraction first, otherwise fall back to
145     // nornmal JNI.  The JNI dispatch abstraction allows the Java plugin
146     // to dispatch the call on the appropriate internal VM thread.
147     RootObject* rootObject = this->rootObject();
148     if (!rootObject)
149         return jsUndefined();
150
151     bool handled = false;
152     if (rootObject->nativeHandle()) {
153         jobject obj = _instance->_instance;
154         JSValue *exceptionDescription = NULL;
155         const char *callingURL = 0;  // FIXME, need to propagate calling URL to Java
156         handled = dispatchJNICall(rootObject->nativeHandle(), obj, jMethod->isStatic(), jMethod->JNIReturnType(), jMethod->methodID(obj), jArgs, result, callingURL, exceptionDescription);
157         if (exceptionDescription) {
158             throwError(exec, GeneralError, exceptionDescription->toString(exec));
159             free (jArgs);
160             return jsUndefined();
161         }
162     }
163     
164     // The following code can be conditionally removed once we have a Tiger update that
165     // contains the new Java plugin.  It is needed for builds prior to Tiger.
166     if (!handled) {    
167         jobject obj = _instance->_instance;
168         switch (jMethod->JNIReturnType()){
169             case void_type:
170                 callJNIMethodIDA<void>(obj, jMethod->methodID(obj), jArgs);
171                 break;            
172             case object_type:
173                 result.l = callJNIMethodIDA<jobject>(obj, jMethod->methodID(obj), jArgs);
174                 break;
175             case boolean_type:
176                 result.z = callJNIMethodIDA<jboolean>(obj, jMethod->methodID(obj), jArgs);
177                 break;
178             case byte_type:
179                 result.b = callJNIMethodIDA<jbyte>(obj, jMethod->methodID(obj), jArgs);
180                 break;
181             case char_type:
182                 result.c = callJNIMethodIDA<jchar>(obj, jMethod->methodID(obj), jArgs);
183                 break;            
184             case short_type:
185                 result.s = callJNIMethodIDA<jshort>(obj, jMethod->methodID(obj), jArgs);
186                 break;
187             case int_type:
188                 result.i = callJNIMethodIDA<jint>(obj, jMethod->methodID(obj), jArgs);
189                 break;
190             
191             case long_type:
192                 result.j = callJNIMethodIDA<jlong>(obj, jMethod->methodID(obj), jArgs);
193                 break;
194             case float_type:
195                 result.f = callJNIMethodIDA<jfloat>(obj, jMethod->methodID(obj), jArgs);
196                 break;
197             case double_type:
198                 result.d = callJNIMethodIDA<jdouble>(obj, jMethod->methodID(obj), jArgs);
199                 break;
200             case invalid_type:
201             default:
202                 break;
203         }
204     }
205         
206     switch (jMethod->JNIReturnType()){
207         case void_type: {
208             resultValue = jsUndefined();
209         }
210         break;
211         
212         case object_type: {
213             if (result.l != 0) {
214                 const char *arrayType = jMethod->returnType();
215                 if (arrayType[0] == '[') {
216                     resultValue = JavaArray::convertJObjectToArray(exec, result.l, arrayType, rootObject);
217                 }
218                 else {
219                     resultValue = Instance::createRuntimeObject(Instance::JavaLanguage, result.l, rootObject);
220                 }
221             }
222             else {
223                 resultValue = jsUndefined();
224             }
225         }
226         break;
227         
228         case boolean_type: {
229             resultValue = jsBoolean(result.z);
230         }
231         break;
232         
233         case byte_type: {
234             resultValue = jsNumber(result.b);
235         }
236         break;
237         
238         case char_type: {
239             resultValue = jsNumber(result.c);
240         }
241         break;
242         
243         case short_type: {
244             resultValue = jsNumber(result.s);
245         }
246         break;
247         
248         case int_type: {
249             resultValue = jsNumber(result.i);
250         }
251         break;
252         
253         case long_type: {
254             resultValue = jsNumber(result.j);
255         }
256         break;
257         
258         case float_type: {
259             resultValue = jsNumber(result.f);
260         }
261         break;
262         
263         case double_type: {
264             resultValue = jsNumber(result.d);
265         }
266         break;
267
268         case invalid_type:
269         default: {
270             resultValue = jsUndefined();
271         }
272         break;
273     }
274
275     free (jArgs);
276
277     return resultValue;
278 }
279
280 JSValue *JavaInstance::defaultValue (JSType hint) const
281 {
282     if (hint == StringType) {
283         return stringValue();
284     }
285     else if (hint == NumberType) {
286         return numberValue();
287     }
288     else if (hint == BooleanType) {
289         return booleanValue();
290     }
291     else if (hint == UnspecifiedType) {
292         JavaClass *aClass = static_cast<JavaClass*>(getClass());
293         if (aClass->isStringClass()) {
294             return stringValue();
295         }
296         else if (aClass->isNumberClass()) {
297             return numberValue();
298         }
299         else if (aClass->isBooleanClass()) {
300             return booleanValue();
301         }
302     }
303     
304     return valueOf();
305 }
306
307 JSValue *JavaInstance::valueOf() const 
308 {
309     return stringValue();
310 }
311
312 JObjectWrapper::JObjectWrapper(jobject instance)
313 : _refCount(0)
314 {
315     assert (instance != 0);
316
317     // Cache the JNIEnv used to get the global ref for this java instanace.
318     // It'll be used to delete the reference.
319     _env = getJNIEnv();
320         
321     _instance = _env->NewGlobalRef (instance);
322     
323     JS_LOG ("new global ref %p for %p\n", _instance, instance);
324
325     if  (_instance == NULL) {
326         fprintf (stderr, "%s:  could not get GlobalRef for %p\n", __PRETTY_FUNCTION__, instance);
327     }
328 }
329
330 JObjectWrapper::~JObjectWrapper() {
331     JS_LOG ("deleting global ref %p\n", _instance);
332     _env->DeleteGlobalRef (_instance);
333 }