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

我创建了foo_callbacks-只是定义了静态的C函数,这些函数在初始化时传递给foo,在这些函数中,我使用JNI再次调用我的应用程序(尚未进行此测试,但我还保留了对jvm的引用并从中获取JNIEnv并附加到当前线程like this)。

但是正在发生什么:

  • 调用JNI以使用foo中的指向静态函数的指针初始化foo_callbacks。我对foo保持静态引用。
  • JNI的单独调用使用现有foo对象
  • 开始计算过程
  • 但是,当foo需要使用我之前传递的回调函数时,会收到以下消息:A/libc: Fatal signal 11 (SIGSEGV), code 1, fault addr 0x4 in tid 14244

  • 谷歌搜索后,似乎我正在尝试访问isn't owned by my app anymore的内存。因此,我认为对回调函数的引用不再有效。所以我的问题是,如何在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);
    }
    ...
    
    FooLib.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;
    }
    

    请注意,这不是经过测试的代码-基本上是我尝试做的事情的简单得多的版本。

    最佳答案

    这是服务旨在解决的问题。有三种形式:与用户交互的前台服务;在后台执行工作的后台服务;和绑定服务(客户端/服务器)的存在时间,只要将客户端应用程序绑定到它们即可。将JNI代码实现为绑定服务,并在其之上进行Java的薄包装。然后您将获得持久性。

    10-07 18:48
    查看更多