从C++类崩溃到Java的JNI回调

Question

下面是一些代码：

Java代码：

//this is what I want to call from native code
public void something(String msg)
{
//do something with msg
}

public void somethingElse()
{
    callNative();
}

private native void callNatve();

//access native
static
{
    System.loadLibrary("someLib");
}

上面所有的工作都很好，但是C++试图做同样的事情，却做不到。（注意：我需要本机库中的类作为类，而不是独立的静态调用）

#include <string>
#include <jni.h>

class MyClass
{
    //ctor
    //dtor

    void someCall(std::string)

    static JNIEnv* envRef;
    static JavaVM* jvmRef;
    static jobject objRef;
};

#include <MyClass.h>

//static members
MyClass:;:JNIEnv* envRef;
MyClass::JavaVM* jvmRef;
MyClass::jobject objRef;

//this is the method whose instructions are crashing
void MyClass::someCall(std::string msg)
{
     //works assuming i call env->NewGlobalRef(MyClass::objRef) or setup/reattach from jvm in exported call or here
     jstring passMsg = envRef->NewStringUTF(msg.c_str());

    clsRef = envRef->GetObjectClass(objRef);
    if(clsRef == NULL)
    {
        return;
    }

    //This doesn't cause crash, but if I call FindClass("where/is/MyClass"); it does... strange
    jmethodID id = envRef->GetMethodID(clsRef, "something", "(Ljava/lang/String;)V");
    if(id == NULL)
    {
        return;
    }

    //Crashes
    //envRef->CallVoidMethod(clsRef, id, passMsg);

    if(envRef->ExceptionCheck())
    {
        envRef->ExceptionDescribe();
    }

    //Also crashes
    //jvmRef->DetachCurrentThread();
}

//this works
extern "C"
{
    JNIEXPORT void JNICALL Java_com_my_project_class_callNative(JNIEnv* env, jobject obj)
    {
        MyClass::objRef = env->NewGlobalRef(obj);
        MyClass::envRef = env;

        //tried both
        //MyClass::envRef->GetJavaVM(&MyClass::jvmRef);
        env->GetJavaVM(&MyClass::jvmRef);


        //Tried this
        /*
        int envStat = MyClass::jvmRef->GetEnv((void**)&MyClass::envRef, JNI_VERSION_1_6);
        if(envStat == JNI_EDETACHED)
        {
            //TODO: LOG
            //std::cout << "GetEnv: not attached" << std::endl;
            if(MyClass::jvmRef->AttachCurrentThread(&MyClass::envRef, NULL) != 0)
            {
                //TODO: LOG
                //std::cout << "Failed to attach" << std::endl;
            }
        }else if(envStat == JNI_OK)
        {
            //
        }else if(envStat == JNI_EVERSION)
        {
            //TODO: LOG
            //std::cout << "GetEnv: version not supported" << std::endl;
        }
        */

        //calling detachcurrentthread here crashes if set above

        MyClassObj.someCall(an std::string);
    }
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void* reserved)
{
    MyClass::jvmRef = jvm;

    return JNI_VERSION_1_6;
}

更新了MyClass：：SomeCall定义：

void MyClass::someCall(std::string msg)
{
    //Get environment from cached jvm
    JNIEnv* env;
    jclass cls;

    int envStat = MyClass::jvmRef->GetEnv((void**)&env, JNI_VERSION_1_6);

    bool attached = false;
    if(envStat == JNI_EDETACHED)
    {
        //TODO: LOG
        if(JavaInterface::jvmRef->AttachCurrentThread(&env, NULL) != 0)
        {
            //TODO: LOG
            // "Failed to attach"
            return;
        }else if(envStat == JNI_OK)
        {
            attached = true;
        }else if(envStat == JNI_EVERSION)
        {
            //TODO: LOG
            // "GetEnv: version not supported"
        }
    }

     cls = env->FindClass("package/location/project/JavaClass");
    if(cls == NULL)
    {
        //TODO: LOG
        return;
    }

    jmethodID id = env->GetMethodID(cls, "something", "(Ljava/lang/String;)V");
    if(id == NULL)
    {
        return;
    }

    jstring passMsg = env->NewStringUTF(msg.c_str());

    //Crashes
    env->CallVoidMethod(cls, id, passMsg);

    if(attached)
        jvmRef->DetachCurrentThread();
 }

Answer 1

Edit#1更改后的错误是，我向CallVoidMethod（）传递了错误的对象。我最后做的工作是将callNative传递的jobject存储为MyClass的静态成员，并将其传递给CallVoidMethod，而不是CLS。

早先的电话：

JNIEXPORT void JNICALL Java_path_to_project_JavaClass_nativeCall(JNIEnv* env, jobject obj)
{
    JavaInterface::objRef = env->NewGlobalRef(obj)
}

在不再需要DeleteGlobalRef（objRef）之后，将在其他地方调用它。然后，唯一的变化是原生的“someCall”方法：

void MyClass::someCall(std::string msg)
{
    //everything here is the same

    //Now either of these will work
    cls = env->FindClass("com/empsoftworks/andr3ds/NativeInterface");
//cls = env->GetObjectClass(objRef);

    //unchanged stuff

    //This is what fixed it
    env->CallVoidMethod(objRef, id, passMsg);
}