Reviewed by Sam.
[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)callJNIObjectMethod (_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 = callJNIDoubleMethod (_instance->_instance, "doubleValue", "()D");
92     return jsNumber(doubleValue);
93 }
94
95 JSValue *JavaInstance::booleanValue() const
96 {
97     jboolean booleanValue = callJNIBooleanMethod (_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                 callJNIVoidMethodIDA (obj, jMethod->methodID(obj), jArgs);
171             }
172             break;
173             
174             case object_type: {
175                 result.l = callJNIObjectMethodIDA (obj, jMethod->methodID(obj), jArgs);
176             }
177             break;
178             
179             case boolean_type: {
180                 result.z = callJNIBooleanMethodIDA (obj, jMethod->methodID(obj), jArgs);
181             }
182             break;
183             
184             case byte_type: {
185                 result.b = callJNIByteMethodIDA (obj, jMethod->methodID(obj), jArgs);
186             }
187             break;
188             
189             case char_type: {
190                 result.c = callJNICharMethodIDA (obj, jMethod->methodID(obj), jArgs);
191             }
192             break;
193             
194             case short_type: {
195                 result.s = callJNIShortMethodIDA (obj, jMethod->methodID(obj), jArgs);
196             }
197             break;
198             
199             case int_type: {
200                 result.i = callJNIIntMethodIDA (obj, jMethod->methodID(obj), jArgs);
201             }
202             break;
203             
204             case long_type: {
205                 result.j = callJNILongMethodIDA (obj, jMethod->methodID(obj), jArgs);
206             }
207             break;
208             
209             case float_type: {
210                 result.f = callJNIFloatMethodIDA (obj, jMethod->methodID(obj), jArgs);
211             }
212             break;
213             
214             case double_type: {
215                 result.d = callJNIDoubleMethodIDA (obj, jMethod->methodID(obj), jArgs);
216             }
217             break;
218
219             case invalid_type:
220             default: {
221             }
222             break;
223         }
224     }
225         
226     switch (jMethod->JNIReturnType()){
227         case void_type: {
228             resultValue = jsUndefined();
229         }
230         break;
231         
232         case object_type: {
233             if (result.l != 0) {
234                 const char *arrayType = jMethod->returnType();
235                 if (arrayType[0] == '[') {
236                     resultValue = JavaArray::convertJObjectToArray(exec, result.l, arrayType, rootObject);
237                 }
238                 else {
239                     resultValue = Instance::createRuntimeObject(Instance::JavaLanguage, result.l, rootObject);
240                 }
241             }
242             else {
243                 resultValue = jsUndefined();
244             }
245         }
246         break;
247         
248         case boolean_type: {
249             resultValue = jsBoolean(result.z);
250         }
251         break;
252         
253         case byte_type: {
254             resultValue = jsNumber(result.b);
255         }
256         break;
257         
258         case char_type: {
259             resultValue = jsNumber(result.c);
260         }
261         break;
262         
263         case short_type: {
264             resultValue = jsNumber(result.s);
265         }
266         break;
267         
268         case int_type: {
269             resultValue = jsNumber(result.i);
270         }
271         break;
272         
273         case long_type: {
274             resultValue = jsNumber(result.j);
275         }
276         break;
277         
278         case float_type: {
279             resultValue = jsNumber(result.f);
280         }
281         break;
282         
283         case double_type: {
284             resultValue = jsNumber(result.d);
285         }
286         break;
287
288         case invalid_type:
289         default: {
290             resultValue = jsUndefined();
291         }
292         break;
293     }
294
295     free (jArgs);
296
297     return resultValue;
298 }
299
300 JSValue *JavaInstance::defaultValue (JSType hint) const
301 {
302     if (hint == StringType) {
303         return stringValue();
304     }
305     else if (hint == NumberType) {
306         return numberValue();
307     }
308     else if (hint == BooleanType) {
309         return booleanValue();
310     }
311     else if (hint == UnspecifiedType) {
312         JavaClass *aClass = static_cast<JavaClass*>(getClass());
313         if (aClass->isStringClass()) {
314             return stringValue();
315         }
316         else if (aClass->isNumberClass()) {
317             return numberValue();
318         }
319         else if (aClass->isBooleanClass()) {
320             return booleanValue();
321         }
322     }
323     
324     return valueOf();
325 }
326
327 JSValue *JavaInstance::valueOf() const 
328 {
329     return stringValue();
330 }
331
332 JObjectWrapper::JObjectWrapper(jobject instance)
333 : _refCount(0)
334 {
335     assert (instance != 0);
336
337     // Cache the JNIEnv used to get the global ref for this java instanace.
338     // It'll be used to delete the reference.
339     _env = getJNIEnv();
340         
341     _instance = _env->NewGlobalRef (instance);
342     
343     JS_LOG ("new global ref %p for %p\n", _instance, instance);
344
345     if  (_instance == NULL) {
346         fprintf (stderr, "%s:  could not get GlobalRef for %p\n", __PRETTY_FUNCTION__, instance);
347     }
348 }
349
350 JObjectWrapper::~JObjectWrapper() {
351     JS_LOG ("deleting global ref %p\n", _instance);
352     _env->DeleteGlobalRef (_instance);
353 }