jni 回调demo

package com.test.jnidemo;

public class NativeUtils {
    static {
        System.loadLibrary("native2-lib");//生成的so名称
    }

    public native static String getAppName(String id);
    public native static int registerCallback(JniCallback call);
    public native static int unregisterCallback();
}

#include <jni.h>
#include <string>
#include <thread>
#include <chrono>
#include "jniinc/android_debug.h"

JavaVM *g_jvm = NULL;
jobject g_callback = NULL;
jclass g_callbackclass = NULL;
jmethodID g_callbackupdate =NULL;
std::thread* g_thread = NULL;
bool  g_run = false;
jstring str2jstring(JNIEnv* env,const char* pat)
{
    //定义java String类 strClass
    jclass strClass = (env)->FindClass("Ljava/lang/String;");
    //获取String(byte[],String)的构造器,用于将本地byte[]数组转换为一个新String
    jmethodID ctorID = (env)->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
    //建立byte数组
    jbyteArray bytes = (env)->NewByteArray(strlen(pat));
    //将char* 转换为byte数组
    (env)->SetByteArrayRegion(bytes, 0, strlen(pat), (jbyte*)pat);
    // 设置String, 保存语言类型,用于byte数组转换至String时的参数
    jstring encoding = (env)->NewStringUTF("GB2312");
    //将byte数组转换为java String,并输出
    return (jstring)(env)->NewObject(strClass, ctorID, bytes, encoding);
}


std::string jstring2str(JNIEnv* env, jstring jstr)
{
    char*   rtn   =   NULL;
    std::string stemp;
    jclass   clsstring   =   env->FindClass("java/lang/String");
    jstring   strencode   =   env->NewStringUTF("GB2312");
    jmethodID   mid   =   env->GetMethodID(clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
    jbyteArray   barr=   (jbyteArray)env->CallObjectMethod(jstr,mid,strencode);
    jsize   alen   =   env->GetArrayLength(barr);
    jbyte*   ba   =   env->GetByteArrayElements(barr,JNI_FALSE);
    if(alen   >   0)
    {
        rtn   =   (char*)malloc(alen+1);
        memcpy(rtn,ba,alen);
        rtn[alen]=0;
        stemp.append(rtn);
    }
    env->ReleaseByteArrayElements(barr,ba,0);
    free(rtn);
    return   stemp;
}

#ifdef __cplusplus
extern "C" {
#endif

JNIEXPORT jstring JNICALL
Java_com_test_jnidemo_NativeUtils_getAppName
        (JNIEnv *env, jobject, jstring str)
{
    //g_callbackclass = env->FindClass("com/test/jnidemo/JniCallback");
    std::string strdata ="hello ";
    strdata.append(jstring2str(env,str));
    return env->NewStringUTF(strdata.c_str());
}

    /*
 * Class:     com_test_jnidemo_NativeUtils
 * Method:    registerCallback
 * Signature: (Lcom/test/jnidemo/JniCallback;)I
 */
    JNIEXPORT jint JNICALL Java_com_test_jnidemo_NativeUtils_registerCallback
            (JNIEnv *env, jclass, jobject jniCallback) {

        env->GetJavaVM(&g_jvm);


        if(!g_thread){
            g_run = true;
            g_callback = env->NewGlobalRef(jniCallback);
             //方法一 必须要(jclass)env->NewGlobalRef(tmp); 否则会为空
            jclass tmp = env->FindClass("com/test/jnidemo/JniCallback");
            g_callbackclass = (jclass)env->NewGlobalRef(tmp);
            //方法二
            //g_callbackclass = tmpenv->GetObjectClass(g_callback);
            g_thread = new std::thread([] {
                jint num = 0;
                JNIEnv *tmpenv;
                if(g_jvm->AttachCurrentThread(&tmpenv, NULL) != JNI_OK) {
                    LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
                    return ;
                }

                while (g_run){
                    std::this_thread::sleep_for(std::chrono::seconds(1));
                   

                    g_callbackupdate = (tmpenv)->GetMethodID(g_callbackclass, "onUpdate", "(I)V");
                    //Attach主线程
                    tmpenv->CallVoidMethod(g_callback,g_callbackupdate,num++);
                    //
                }
                tmpenv->DeleteGlobalRef(g_callbackclass);
                g_jvm->DetachCurrentThread();//一定要报JNIENV从线程解绑定，不然会造成野指针
                g_jvm = NULL;
            });
        }
        return 0;
    }

/*
 * Class:     com_test_jnidemo_NativeUtils
 * Method:    unregisterCallback
 * Signature: (Lcom/test/jnidemo/JniCallback;)I
 */
    JNIEXPORT jint JNICALL Java_com_test_jnidemo_NativeUtils_unregisterCallback
            (JNIEnv *env, jclass){

            //env->GetJavaVM(&g_jvm);
            //Attach主线程
            JNIEnv *tempenv;
            if (g_jvm->AttachCurrentThread(&tempenv, NULL) != JNI_OK) {
            LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
            return  0;
            }
            g_run = false;
        //std::this_thread::sleep_for(std::chrono::seconds(1));
            if(g_thread){
                g_thread->join();
                g_thread = NULL;
            }
            LOGE("%s:  g_thread->join", __FUNCTION__);
            if(g_callback){
                env->DeleteGlobalRef(g_callback);//使用完一定要释放，不然会造成内存泄漏
                //g_callback =NULL;
            }
            LOGE("%s:  DeleteGlobalRef", __FUNCTION__);

           if(g_jvm){
               //g_jvm->DetachCurrentThread();//一定要报JNIENV从线程解绑定，不然会造成野指针
               g_jvm =NULL;
                //g_jvm->DestroyJavaVM();
            }
            LOGE("%s:  DetachCurrentThread", __FUNCTION__);
            return  0;
}


#ifdef __cplusplus
}
#endif