使用JNI从Java调用之间在内存中保留本机对象

Question

我有一个Android应用程序，需要使用C库。我正在使用jni与它进行接口。该库使用一个结构（我们称之为foo)。foo使用一组初始参数，其中包括指向c函数的指针，它使用这些函数从我的应用程序请求更多数据，并将这些数据合并到计算过程中。一旦它拥有了所需的一切，它就会通过c回调函数返回一个结果，它还需要一个指针。我需要将所有的C回调函数挂接到我的应用程序中，从用户那里获取更多的数据，然后将这些数据返回到foo中，最后通过最终的回调函数将结果显示给我的应用程序中的用户。

我创建了foo_callbacks-刚定义了静态C函数，在初始化时将其传递到foo中，在这些函数中，我使用JNI再次调用我的应用程序（还没有对此进行测试，但我也保留了对JVM的引用，并从中获取JNIENV并附加到当前线程，如下所示）。

但是正在发生的事情是：

1. 调用JNI来初始化foo,并使用指向foo_callbacks中静态函数的指针。我保留了对foo的静态引用。
2. 单独调用JNI将使用现有的foo对象
启动计算过程
3. 但当foo需要使用我前面传递的回调函数时，我会得到以下消息:a/libc:Fatal signal 11(SIGSEGV),code 1,fault addr 0x4 in tid 14244。

在谷歌搜索时，我试图访问的内存似乎不再属于我的应用程序了。所以我认为那些对回调函数的引用不再有效了。所以我的问题是，我如何在JNI调用之间在内存中保留一个本机对象？还是有另一种方法来处理这个问题？多谢了。

下面是一些示例代码：

foomanager.java

...
static {
    System.loadLibrary("FooLib");
}

//initialized Foo library
private native int fooLibInit();

//start the process 
public native int fooStart(String message);

//continue the process after a delay 
public native int fooContinue(String message);

//retrieve milliseconds to schedule next event
public native long fooGetMsToNextEvent();

//method that gets called from native code
public static long getCurrentTime(){
    return System.currentTimeMillis();
}

//method that gets called from native code, returning results
public static void deliverResult(String result){
    //display result to the user
}

...

fooscheduler.java

...
public static void kickItOff(String message){
    FooManager.fooLibInit();
    long timeToWait = FooManager.fooGetMsToNextEvent();
    //this call figures out what step it is and gets some data
    SchedulerUtil.scheduleCallBack(timeToWait);
}

//this is a callback function that gets called after given about of time by SchedulerUtil
public static void callBack(int step, String message){
    if(step == 1)
        FooManager.fooStart(message)
    else FooManager.fooContinue(message);
}
...

folib.cpp

#include <string.h>
#include <jni.h>
#include <android/log.h>

extern "C" {
    #include "blackbox.h"
    #include "foo_wrapper.h"
}

extern "C" {

    static jboolean isJni();
    //struct defined in blackbox.h
    static foo foo_obj;

    JNIEXPORT jint
    JNI_OnLoad(JavaVM *vm, void *reserved) {
        //defined in foo_wrapper.h
        set_java_env(vm);
        return JNI_VERSION_1_6;
    }

    JNIEXPORT jint JNICALL
    Java_com_myapp_fooInit(JNIEnv * env, jobject obj){
        //foo_get_global_time_wrapper and foo_return_result_wrapper functions is defined in foo_wrapper.h.
        //those pointers are actually a member variables of foo_obj,
        //they gets assigned in the fooInit() so foo_obj can use them later. fooInit is defined in blackbox.h
        int resultInit = fooInit(&foo_obj, foo_get_global_time_wrapper, foo_return_result_wrapper);
        return resultInit;
    }

    JNIEXPORT jint JNICALL
    Java_com_myapp_fooStart(JNIEnv * env, jobject obj, jstring message){
        jboolean copy = isJni();
        const char *firstCharPointer = env->GetStringUTFChars(message, &copy);

        //here is where the foo_get_global_time_wrapper function is called, and
        //
        //I am getting A/libc: Fatal signal 11 (SIGSEGV) error.
        //
        //fooStart is defined in blackbox.h
        int resultCode = fooStart(&foo_obj, (uint8*)firstCharPointer, strlen(firstCharPointer));
        return resultCode;
    }

    JNIEXPORT jint JNICALL
    Java_com_myapp_fooContinue(JNIEnv * env, jobject obj, jstring message){
        jboolean copy = isJni();
        const char *firstCharPointer = env->GetStringUTFChars(chunk, &copy);

        //here blackbox produces results based on the first and second messages that were passed in and calls foo_return_result_wrapper with results
        //fooContinue is defined in blackbox.h
        int resultCode = fooContinue(&foo_obj, (uint8*)firstCharPointer, strlen(firstCharPointer));
        return resultCode;
    }


    static jboolean isJni(){
        return JNI_TRUE;
    }
}

foo_wrapper.c

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

static JavaVM *JVM;

extern uint32 foo_get_global_time_wrapper() {
    JNIEnv *env;
    int result = (*JVM)->GetEnv(JVM, (void **) &env, JNI_VERSION_1_6);
    if (result != JNI_OK) {
        LOGI("couldnt get JVM.");
        return 1;
    }

    jclass clazz = (*env)->FindClass(env, "com/myapp/FooManager");
    jmethodID mid = (*env)->GetStaticMethodID(env, clazz, "getCurrentTime", "()J");
    long milliseconds;
    (*env)->CallStaticObjectMethod(env, clazz, mid, milliseconds);
    return milliseconds;
}

extern int foo_return_result_wrapper(const uint8 *start, uint16 length) {
    JNIEnv *env;
    int result = (*JVM)->GetEnv(JVM, (void **) &env, JNI_VERSION_1_6);
    if (result != JNI_OK) {
        LOGI("couldnt get JVM.");
        return 1;
    }

    jstring result = //get jstring from parameters start and length;

    jclass clazz = (*env)->FindClass(env, "com/myapp/FooManager");
    jmethodID mid = (*env)->GetStaticMethodID(env, clazz, "deliverResult", "(LJava.lang.String;)J");

    jobject obj =   (*env)->CallStaticObjectMethod(clazz, mid, result);
    return 0;
}

extern void set_java_env(JavaVM *vm) {
    JVM = vm;
}

请注意，这不是经过测试的代码--它基本上是我尝试做的更简单的版本。

Answer 1

这就是服务被设计用来解决的问题。有三种风格：与用户交互的前台服务；在后台做事情的后台服务；和绑定服务（客户机/服务器）,只要客户机应用程序绑定到它们,它们就会存在。将您的JNI代码实现为绑定的服务,并在其顶部使用Java的薄包装；然后你就会得到你的坚持。