embedding/browser/activex/src/plugin/LiveConnect.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Adam Lock <adamlock@netscape.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38 #include "stdafx.h"
  39
  40 #include "jni.h"
  41 #include "npapi.h"
  42
  43 #include "_java/java_lang_Throwable.h"
  44 #include "_java/java_lang_Error.h"
  45 #include "_java/java_lang_String.h"
  46 #include "_java/java_lang_Boolean.h"
  47 #include "_java/java_lang_Number.h"
  48 #include "_java/java_lang_Integer.h"
  49 #include "_java/java_lang_Long.h"
  50 // TODO:
  51 // These things require certain native statics to be implemented
  52 // so they're commented out for the time being.
  53 //#include "_java/java_lang_Double.h"
  54 //#include "_java/java_lang_Float.h"
  55 #include "_java/java_lang_Character.h"
  56 #include "_java/netscape_plugin_Plugin.h"
  57 #include "_java/MozAxPlugin.h"
  58
  59 #include "LegacyPlugin.h"
  60 #include "LiveConnect.h"
  61
  62 void liveconnect_Shutdown()
  63 {
  64     JRIEnv* env = NPN_GetJavaEnv();
  65     if (env) {
  66         unuse_MozAxPlugin(env);
  67         unuse_netscape_plugin_Plugin(env);
  68         unuse_java_lang_Error(env);
  69 //        unuse_java_lang_String(env);
  70         unuse_java_lang_Number(env);
  71         unuse_java_lang_Boolean(env);
  72         unuse_java_lang_Integer(env);
  73         unuse_java_lang_Long(env);
  74 //        unuse_java_lang_Float(env);
  75 //        unuse_java_lang_Double(env);
  76         unuse_java_lang_Character(env);
  77     }
  78 }
  79
  80 jref liveconnect_GetJavaClass()
  81 {
  82     JRIEnv* env = NPN_GetJavaEnv();
  83     if (env) {
  84         // Note: The order of these is important (for some unknown reason)
  85         //       and was determined through trial and error. Do not rearrange
  86         //       without testing the new order!
  87         use_netscape_plugin_Plugin(env);
  88         jref myClass = (jref) use_MozAxPlugin(env);
  89         use_java_lang_Error(env);
  90 //        use_java_lang_String(env);
  91         use_java_lang_Number(env);
  92         use_java_lang_Boolean(env);
  93         use_java_lang_Integer(env);
  94         use_java_lang_Long(env);
  95 //        use_java_lang_Float(env);
  96 //        use_java_lang_Double(env);
  97         use_java_lang_Character(env);
  98         return myClass;
  99     }
 100     return NULL;
 101 }
 102
 103 // The following will be callable from Javascript through LiveConnect
 104 HRESULT
 105 _GetIDispatchFromJRI(JRIEnv *env, struct MozAxPlugin* self, IDispatch **pdisp)
 106 {
 107     if (pdisp == NULL || env == NULL || self == NULL)
 108     {
 109         return E_INVALIDARG;
 110     }
 111     *pdisp = NULL;
 112
 113     // Note: You get a nasty crash calling self->getPeer(env), this obscure cast fixes
 114     //       it. More details in the link:
 115     //
 116     // http://groups.google.com/groups?selm=385D9543.4087F1C6%40ermapper.com.au&output=gplain
 117
 118     NPP npp = (NPP) netscape_plugin_Plugin_getPeer(env,
 119             reinterpret_cast<netscape_plugin_Plugin*> (self));
 120     PluginInstanceData *pData = (PluginInstanceData *) npp->pdata;
 121     if (pData == NULL)
 122     {
 123         return E_FAIL;
 124     }
 125
 126     IUnknownPtr unk;
 127     HRESULT hr = pData->pControlSite->GetControlUnknown(&unk);
 128     if (unk.GetInterfacePtr() == NULL)
 129     {
 130         return E_FAIL;
 131     }
 132
 133     IDispatchPtr disp = unk;
 134     if (disp.GetInterfacePtr() == NULL)
 135     {
 136         return E_FAIL;
 137     }
 138
 139     *pdisp = disp.GetInterfacePtr();
 140     (*pdisp)->AddRef();
 141
 142     return S_OK;
 143 }
 144
 145 HRESULT
 146 _VariantToJRIObject(JRIEnv *env, VARIANT *v, java_lang_Object **o)
 147 {
 148     if (v == NULL || env == NULL || o == NULL)
 149     {
 150         return E_INVALIDARG;
 151     }
 152
 153     *o = NULL;
 154
 155     // TODO - VT_BYREF will cause problems
 156     if (v->vt == VT_EMPTY)
 157     {
 158         return S_OK;
 159     }
 160     else if (v->vt == VT_BOOL)
 161     {
 162         jbool value = (v->boolVal == VARIANT_TRUE) ? JRITrue : JRIFalse;
 163         java_lang_Boolean *j = java_lang_Boolean_new(env,
 164             class_java_lang_Boolean(env), value);
 165         *o = reinterpret_cast<java_lang_Object *>(j);
 166         return S_OK;
 167     }
 168     else if (v->vt == VT_I4)
 169     {
 170         jlong value = v->lVal;
 171         java_lang_Long *j = java_lang_Long_new(env,
 172             class_java_lang_Long(env), value);
 173         *o = reinterpret_cast<java_lang_Object *>(j);
 174         return S_OK;
 175     }
 176     else if (v->vt == VT_I2)
 177     {
 178         jlong value = v->iVal;
 179         java_lang_Long *j = java_lang_Long_new(env,
 180             class_java_lang_Long(env), value);
 181         *o = reinterpret_cast<java_lang_Object *>(j);
 182         return S_OK;
 183     }
 184 /*  else if (v->vt == VT_R4)
 185     {
 186         jfloat value = v->fltVal;
 187         java_lang_Float *j = java_lang_Float_new(env,
 188             class_java_lang_Float(env), value);
 189         *o = reinterpret_cast<java_lang_Object *>(j);
 190         return S_OK;
 191     }
 192     else if (v->vt == VT_R8)
 193     {
 194         jdouble value = v->dblVal;
 195         java_lang_Double *j = java_lang_Double_new(env,
 196             class_java_lang_Double(env), value);
 197         *o = reinterpret_cast<java_lang_Object *>(j);
 198         return S_OK;
 199     } */
 200     else if (v->vt == VT_BSTR)
 201     {
 202         USES_CONVERSION;
 203         char * value = OLE2A(v->bstrVal);
 204         java_lang_String *j = JRI_NewStringUTF(env, value, strlen(value));
 205         *o = reinterpret_cast<java_lang_Object *>(j);
 206         return S_OK;
 207     }
 208     /* TODO else if VT_UI1 etc. */
 209
 210     return E_FAIL;
 211 }
 212
 213 HRESULT
 214 _JRIObjectToVariant(JRIEnv *env, java_lang_Object *o, VARIANT *v)
 215 {
 216     VariantInit(v);
 217     if (JRI_IsInstanceOf(env, (jref) o, class_java_lang_String(env)))
 218     {
 219         USES_CONVERSION;
 220         const char *value = JRI_GetStringUTFChars(env, reinterpret_cast<java_lang_String *>(o));
 221         v->vt = VT_BSTR;
 222         v->bstrVal = SysAllocString(A2COLE(value));
 223     }
 224     else if (JRI_IsInstanceOf(env, (jref) o, class_java_lang_Boolean(env)))
 225     {
 226         jbool value = java_lang_Boolean_booleanValue(env, reinterpret_cast<java_lang_Boolean *>(o));
 227         v->vt = VT_BOOL;
 228         v->boolVal = value == JRITrue ? VARIANT_TRUE : VARIANT_FALSE;
 229     }
 230     else if (JRI_IsInstanceOf(env, o, class_java_lang_Integer(env)))
 231     {
 232         jint value = java_lang_Integer_intValue(env, reinterpret_cast<java_lang_Integer *>(o));
 233         v->vt = VT_I4;
 234         v->lVal = value;
 235     }
 236     else if (JRI_IsInstanceOf(env, o, class_java_lang_Long(env)))
 237     {
 238         jlong value = java_lang_Long_longValue(env, reinterpret_cast<java_lang_Long *>(o));
 239         v->vt = VT_I4;
 240         v->lVal = value;
 241     }
 242 /*  else if (JRI_IsInstanceOf(env, o, class_java_lang_Double(env)))
 243     {
 244         jdouble  value = java_lang_Double_doubleValue(env, reinterpret_cast<java_lang_Double *>(o));
 245         v->vt = VT_R8;
 246         v->dblVal = value;
 247     }
 248     else if (JRI_IsInstanceOf(env, o, class_java_lang_Float(env)))
 249     {
 250         jfloat value = java_lang_Float_floatValue(env, reinterpret_cast<java_lang_Float *>(o));
 251         v->vt = VT_R4;
 252         v->fltVal = value;
 253     } */
 254     else if (JRI_IsInstanceOf(env, o, class_java_lang_Character(env)))
 255     {
 256         jchar value = java_lang_Character_charValue(env, reinterpret_cast<java_lang_Character *>(o));
 257         v->vt = VT_UI1;
 258         v->bVal = value;
 259     }
 260     else if (JRI_IsInstanceOf(env, o, class_java_lang_Number(env)))
 261     {
 262         jlong value = java_lang_Number_longValue(env, reinterpret_cast<java_lang_Number *>(o));
 263         v->vt = VT_I4;
 264         v->lVal = value;
 265     }
 266     else
 267     {
 268         // TODO dump diagnostic error here
 269         return E_FAIL;
 270     }
 271     return S_OK;
 272 }
 273
 274 struct java_lang_Object *
 275 _InvokeFromJRI(JRIEnv *env, struct MozAxPlugin* self, struct java_lang_String *func, int nargs, java_lang_Object *args[])
 276 {
 277     HRESULT hr;
 278     DISPID dispid = 0;
 279
 280     // call the requested function
 281     const char* funcName = JRI_GetStringUTFChars(env, func);
 282
 283     IDispatchPtr disp;
 284     if (FAILED(_GetIDispatchFromJRI(env, self, &disp)))
 285     {
 286         return NULL;
 287     }
 288
 289     _variant_t *vargs = new _variant_t[nargs];
 290     for (int i = 0; i < nargs; i++)
 291     {
 292         if (FAILED(_JRIObjectToVariant(env, args[i], &vargs[i])))
 293         {
 294             delete []vargs;
 295             char error[64];
 296             sprintf(error, "Argument %d could not be converted into a variant", i);
 297             JRI_ThrowNew(env, class_java_lang_Error(env), error);
 298             return NULL;
 299         }
 300     }
 301
 302     USES_CONVERSION;
 303     OLECHAR FAR* szMember = A2OLE(funcName);
 304     hr = disp->GetIDsOfNames(IID_NULL, &szMember, 1, LOCALE_USER_DEFAULT, &dispid);
 305     if (FAILED(hr))
 306     {
 307         char error[128];
 308         memset(error, 0, sizeof(error));
 309         _snprintf(error, sizeof(error) - 1, "invoke failed, member \"%s\" not found, hr=0x%08x", funcName, hr);
 310         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 311         return NULL;
 312     }
 313
 314     DISPPARAMS dispparams = {NULL, NULL, 0, 0};
 315     dispparams.rgvarg = vargs;
 316     dispparams.cArgs = nargs;
 317
 318     _variant_t vResult;
 319     hr = disp->Invoke(
 320         dispid,
 321         IID_NULL,
 322         LOCALE_USER_DEFAULT,
 323         DISPATCH_METHOD,
 324         &dispparams, &vResult, NULL, NULL);
 325
 326     if (FAILED(hr))
 327     {
 328         char error[64];
 329         sprintf(error, "invoke failed, result from object = 0x%08x", hr);
 330         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 331         return NULL;
 332     }
 333
 334     java_lang_Object *oResult = NULL;
 335     _VariantToJRIObject(env, &vResult, &oResult);
 336
 337     return reinterpret_cast<java_lang_Object *>(oResult);
 338 }
 339
 340 /*******************************************************************************
 341  * Native Methods:
 342  * These are the native methods which we are implementing.
 343  ******************************************************************************/
 344
 345 /*** private native xinvoke (Ljava/lang/String;)Ljava/lang/Object; ***/
 346 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 347 native_MozAxPlugin_xinvoke(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a)
 348 {
 349     return _InvokeFromJRI(env, self, a, 0, NULL);
 350 }
 351
 352 /*** private native xinvoke1 (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object; ***/
 353 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 354 native_MozAxPlugin_xinvoke1(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, struct java_lang_Object *b)
 355 {
 356     java_lang_Object *args[1];
 357     args[0] = b;
 358     return _InvokeFromJRI(env, self, a, sizeof(args) / sizeof(args[0]), args);
 359 }
 360
 361 /*** private native xinvoke2 (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ***/
 362 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 363 native_MozAxPlugin_xinvoke2(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, struct java_lang_Object *b, struct java_lang_Object *c)
 364 {
 365     java_lang_Object *args[2];
 366     args[0] = b;
 367     args[1] = c;
 368     return _InvokeFromJRI(env, self, a, sizeof(args) / sizeof(args[0]), args);
 369 }
 370
 371 /*** private native xinvoke3 (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ***/
 372 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 373 native_MozAxPlugin_xinvoke3(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, struct java_lang_Object *b, struct java_lang_Object *c, struct java_lang_Object *d)
 374 {
 375     java_lang_Object *args[3];
 376     args[0] = b;
 377     args[1] = c;
 378     args[2] = d;
 379     return _InvokeFromJRI(env, self, a, sizeof(args) / sizeof(args[0]), args);
 380 }
 381
 382 /*** private native xinvoke4 (Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ***/
 383 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 384 native_MozAxPlugin_xinvoke4(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, struct java_lang_Object *b, struct java_lang_Object *c, struct java_lang_Object *d, struct java_lang_Object *e)
 385 {
 386     java_lang_Object *args[4];
 387     args[0] = b;
 388     args[1] = c;
 389     args[2] = d;
 390     args[3] = e;
 391     return _InvokeFromJRI(env, self, a, sizeof(args) / sizeof(args[0]), args);
 392 }
 393
 394 /*** private native xinvokeX (Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object; ***/
 395 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 396 native_MozAxPlugin_xinvokeX(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, jobjectArray b)
 397 {
 398     // Turn the Java array of objects into a C++ array
 399     jsize length = JRI_GetObjectArrayLength(env, b);
 400     java_lang_Object **args = NULL;
 401     if (length)
 402     {
 403         args = (java_lang_Object **) malloc(length * sizeof(java_lang_Object *));
 404         for (long i = 0; i < length; i++)
 405         {
 406              args[i] = reinterpret_cast<java_lang_Object *>(JRI_GetObjectArrayElement(env, b, i));
 407         }
 408     }
 409     java_lang_Object *o = _InvokeFromJRI(env, self, a, length, args);
 410     free(args);
 411     return o;
 412 }
 413
 414 /*** private native xgetProperty (Ljava/lang/String;)Ljava/lang/Object; ***/
 415 extern "C" JRI_PUBLIC_API(struct java_lang_Object *)
 416 native_MozAxPlugin_xgetProperty(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a)
 417 {
 418     HRESULT hr;
 419     DISPID dispid;
 420     _variant_t vResult;
 421
 422     IDispatchPtr disp;
 423     if (FAILED(_GetIDispatchFromJRI(env, self, &disp)))
 424     {
 425         return NULL;
 426     }
 427
 428     // return the requested property to the Java peer
 429     USES_CONVERSION;
 430     OLECHAR FAR* szMember = A2OLE(JRI_GetStringUTFChars(env, a));
 431     hr = disp->GetIDsOfNames(IID_NULL, &szMember, 1, LOCALE_USER_DEFAULT, &dispid);
 432     if (FAILED(hr))
 433     {
 434         char error[128];
 435         memset(error, 0, sizeof(error));
 436         _snprintf(error, sizeof(error) - 1, "getProperty failed, member \"%s\" not found, hr=0x%08x", szMember, hr);
 437         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 438         return NULL;
 439     }
 440     DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};
 441     hr = disp->Invoke(
 442         dispid,
 443         IID_NULL,
 444         LOCALE_USER_DEFAULT,
 445         DISPATCH_PROPERTYGET,
 446         &dispparamsNoArgs, &vResult, NULL, NULL);
 447     if (FAILED(hr))
 448     {
 449         char error[64];
 450         sprintf(error, "getProperty failed, result from object = 0x%08x", hr);
 451         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 452         return NULL;
 453     }
 454
 455     java_lang_Object *oResult = NULL;
 456     _VariantToJRIObject(env, &vResult, &oResult);
 457
 458     return oResult;
 459 }
 460
 461 /*** private native xsetProperty2 (Ljava/lang/String;Ljava/lang/Object;)V ***/
 462 extern "C" JRI_PUBLIC_API(void)
 463 native_MozAxPlugin_xsetProperty2(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, struct java_lang_Object *b)
 464
 465 {
 466     HRESULT hr;
 467     DISPID dispid;
 468     VARIANT VarResult;
 469
 470     IDispatchPtr disp;
 471     if (FAILED(_GetIDispatchFromJRI(env, self, &disp)))
 472     {
 473         return;
 474     }
 475
 476     USES_CONVERSION;
 477     OLECHAR FAR* szMember = A2OLE(JRI_GetStringUTFChars(env, a));
 478     hr = disp->GetIDsOfNames(IID_NULL, &szMember, 1, LOCALE_USER_DEFAULT, &dispid);
 479     if (FAILED(hr))
 480     {
 481         char error[128];
 482         memset(error, 0, sizeof(error));
 483         _snprintf(error, sizeof(error) - 1, "setProperty failed, member \"%s\" not found, hr=0x%08x", szMember, hr);
 484         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 485         return;
 486     }
 487
 488     _variant_t *pvars = new _variant_t[1];
 489     if (FAILED(_JRIObjectToVariant(env, b, &pvars[0])))
 490     {
 491         delete []pvars;
 492         char error[64];
 493         sprintf(error, "Property value could not be converted into a variant");
 494         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 495         return;
 496     }
 497
 498     DISPID dispIdPut = DISPID_PROPERTYPUT;
 499
 500     DISPPARAMS functionArgs;
 501     functionArgs.rgdispidNamedArgs = &dispIdPut;
 502     functionArgs.rgvarg = pvars;
 503     functionArgs.cArgs = 1;
 504     functionArgs.cNamedArgs = 1;
 505
 506     hr = disp->Invoke(
 507         dispid,
 508         IID_NULL,
 509         LOCALE_USER_DEFAULT,
 510         DISPATCH_PROPERTYPUT,
 511         &functionArgs, &VarResult, NULL, NULL);
 512
 513     delete []pvars;
 514
 515     if (FAILED(hr))
 516     {
 517         char error[64];
 518         sprintf(error, "setProperty failed, result from object = 0x%08x", hr);
 519         JRI_ThrowNew(env, class_java_lang_Error(env), error);
 520         return;
 521     }
 522 }
 523
 524 /*** private native xsetProperty1 (Ljava/lang/String;Ljava/lang/String;)V ***/
 525 extern "C" JRI_PUBLIC_API(void)
 526 native_MozAxPlugin_xsetProperty1(JRIEnv* env, struct MozAxPlugin* self, struct java_lang_String *a, struct java_lang_String *b)
 527 {
 528     native_MozAxPlugin_xsetProperty2(env, self, a, reinterpret_cast<java_lang_Object *>(b));
 529 }
 530
 531
 532 ///////////////////////////////////////////////////////////////////////////////
 533
 534 /*** private native printStackTrace0 (Ljava/io/PrintStream;)V ***/
 535 extern "C" JRI_PUBLIC_API(void)
 536 native_java_lang_Throwable_printStackTrace0(JRIEnv* env, struct java_lang_Throwable* self, struct java_io_PrintStream *a)
 537 {
 538 }
 539
 540 /*** public native fillInStackTrace ()Ljava/lang/Throwable; ***/
 541 extern "C" JRI_PUBLIC_API(struct java_lang_Throwable *)
 542 native_java_lang_Throwable_fillInStackTrace(JRIEnv* env, struct java_lang_Throwable* self)
 543 {
 544     return self;
 545 }