🚀 go-pugleaf

Alberto Fdez wrote:

> On Fri, 01 Dec 2000 23:36:21 +0100, Juan Gonzalo de Silva Medina
> <gonzalo@caymasa.es> wrote:
> 
> (.....)

> 
> 	Si, pero mi problema es que NO tengo en mi c�digo Java, ninguna llamada
> "native" (No la necesito, ni quiero).
> 
> La notificaci�n C++ hacia Java a de ser espontanea, sin ninguna llamada previa
> (desde Java) a un metodo nativo (en C++)


Bueno es un poco estremista eso de que ni la necesitas ni la quieres....
En cuanto a lo de espontanea, no lo creo, yo diria que no sabes en el 
tiempo cuando se produce,pero desde luego has de saber a quien has de 
invocar...


> (... Cortado ...)
> 
> Presuponiendo que me hago una "native", una que se llame "InicializaCosas()"
> (por ejemplo), para as� obtener el entorno del hilo en donde mi VM corra.
> 
> private native int InicializaCosas(void){...}
> /* Y en C++, el H, tras pasar el javah.. que quede: */
> InicializaCosas
> JNIEXPORT jint JNICALL Java_InicializaCosas (JNIEnv *, jobject); // � Similar.
> 
> El problema que detro de Java_InicializaCosas() Na llama a ningun metodo Java
> sino en un hilo distinto (y dios sabe cuando) en dodnde le tengo que llamar.
> 
> Lo Obvio, parece que es guardar el JNIEnv *,... en alguna variable global (o
> similar) para posteriormente usarlo, pero no funciona.


Por supuesto que no funciona, eso viene en la documentaci�n, si pasas 
JNIEnv * entre hilos no sirve...

Sigo opinando que estas un poco "cerrado en banda" :) sigues 
considerando una parte del problema y no todo en su conjunto. Si no se 
adapta Java a lo que tu quieres hacer, adaptat� a lo que hace Java, te 
ser� mucho m�s sencillo :).

Vamos a ver, �Qu� problema tienes en que el m�todo C++ no sea un 
thread?, es por gusto o por que tienes una DLL que vas ha llamar que a 
su vez hace un thread...

Perdona, pero me parece que est�s liando el tema innecesariamente.

Y dejando esto de lado, creo que lo puedes hacer de la siguiente manera, 
aunque no lo he probado:

En java llamas a un m�todo Java_InicializaCosas(JNIEnv*, jobject);

En dicho objeto java creas el m�todo al que vas a invocar cuando ocurra 
lo que sea en el thread en C++.

En el programa nativo haces:


static jclass cls = 0;
static jfieldID fid;

JNIEXPORT void JNICALL
Java_InicializaCosas(JNIEnv *env, jobject obj)
{
     if (cls == 0) {
         jclass cls1 = (*env)->GetObjectClass(env, obj);
         if (cls1 == 0) {
		.../*Error*/
         }
         cls = (*env)->NewGlobalRef(env, cls1);
         if (cls == 0) {
             ... /* error */
         }
         fid = (*env)->GetStaticFieldID(env, cls, "llamada", "I");
     }

/*llamar al m�todo*/
}


Una vez en tu thread C++ has de llamar (con los mecanismos jni normales) 
utilizando el objeto jclass.

Esto lo que realmente hace es crear un apuntador global al objeto en 
Java, para que no se pierda (sea recuperado por el GC).

No se si te servir�, por lo menos es lo �nico que he conseguido 
encontrar que se adapta a lo que tu quieres exactamente.

Pero OJO, has de llamar a DeleteGlobalRef para eliminarla, sino en Java 
NUNCA se destruir� la instancia del objeto.

A mi esto me parece mucho m�s rebuscado y no es thread-safe...

Espero tu respuesta :)

Saludos,

--
Juan Gonzalo de Silva Medina
if(!Linux) throw new Exception(" :( ");