1.关于JNIEnv和JavaVM
JNIEnv是一个与线程相关的变量，不同线程的JNIEnv彼此独立。JavaVM是虚拟机在JNI层的代表，在一个虚拟机进程中只有一个 JavaVM，因此该进程的所有线程都可以使用这个JavaVM。当后台线程需要调用JNI native时，在native库中使用全局变量保存JavaVM尤为重要，这样使得后台线程能通过JavaVM获得JNIEnv。
native程序中频繁使用JNIEnv*和JavaVM*。而C和C++代码使用JNIEnv*和JavaVM*这两个指针的做法是有区别的，网上大部分代码都使用C++，基本上找不到关于C和C++在这个问题上的详细叙述。
在C中：
使用JNIEnv* env要这样 (*env)->方法名(env,参数列表)
使用JavaVM* vm要这样 (*vm)->方法名(vm,参数列表)
在C++中：
使用JNIEnv* env要这样 env->方法名(参数列表)
使用JavaVM* vm要这样 vm->方法名(参数列表)
上面这二者的区别是，在C中必须先对env和vm间接寻址（得到的内容仍然是一个指针），在调用方法时要将env或vm传入作为第一个参数。C++则直接 利用env和vm指针调用其成员。那到底C中的(*env)和C++中的env是否有相同的数据类型呢？C中的(*vm) 和C++中的vm是否有相同的数据类型呢？
为了验证上面的猜测，我们可以查看JNIEnv和JavaVM的定义。他们位于头文件jni.h。我开发JNI用的是android-5平台，下面是 $NDK\platforms\android-5\arch-arm\usr\include\jni.h的部分代码
[cpp] view plaincopy
struct _JNIEnv;
struct _JavaVM;
#if defined(__cplusplus)
typedef _JNIEnv JNIEnv; //C++使用这个类型
typedef _JavaVM JavaVM; //C++使用这个类型
#else
typedef const struct JNINativeInterface* JNIEnv; //C使用这个类型
typedef const struct JNIInvokeInterface* JavaVM; //C使用这个类型
#endif
struct JNINativeInterface
{
/****省略了的代码****/
jmethodID (*GetMethodID)(JNIEnv*, jclass, const char*, const char*);
/****省略了的代码****/
jobject (*GetStaticObjectField)(JNIEnv*, jclass, jfieldID);
/****省略了的代码****/
};
struct _JNIEnv
{
const struct JNINativeInterface* functions;
#if defined(__cplusplus)
/****省略了的代码****/
jmethodID GetMethodID(jclass clazz, const char* name, const char* sig)
{ return functions->GetMethodID(this, clazz, name, sig); }
/****省略了的代码****/
jobject GetStaticObjectField(jclass clazz, jfieldID fieldID)
{ return functions->GetStaticObjectField(this, clazz, fieldID); }
/****省略了的代码****/
#endif /*__cplusplus*/
};
struct JNIInvokeInterface
{
/****省略了的代码****/
jint (*GetEnv)(JavaVM*, void**, jint);
jint (*AttachCurrentThreadAsDaemon)(JavaVM*, JNIEnv**, void*);
};
struct _JavaVM
{
const struct JNIInvokeInterface* functions;
#if defined(__cplusplus)
/****省略了的代码****/
jint GetEnv(void** env, jint version)
{ return functions->GetEnv(this, env, version); }
jint AttachCurrentThreadAsDaemon(JNIEnv** p_env, void* thr_args)
{ return functions->AttachCurrentThreadAsDaemon(this, p_env, thr_args); }
#endif /*__cplusplus*/
};
假如我们用C编码，宏__cplusplus没有定义，那么从最上面的宏#if defined(__cplusplus)可推断
JNIEnv 代表类型 const struct JNINativeInterface*
JavaVM 代表类型 const struct JNIInvokeInterface*
那么JNIEnv* env实际上等价于声明 const struct JNINativeInterface** env
JavaVM* vm实际上等价于声明 const struct JNIInvokeInterface ** vm
因此要调用JNINativeInterface结构体内的函数指针就必须先对env间接寻址。
(*env)的类型是const struct JNINativeInterface*（指向JNINativeInterface结构体的指针），这时候可以用这个指针调用结构体的成员函数指针, (*env)-> GetMethodID(env, jclass, const char*, const char*)。同理可分析JavaVM* vm。
----------------------------------------------------------------------------------------------------------------------------------------------
假如我们用C++编码，宏__cplusplus有定义，那么从最上面的宏#if defined(__cplusplus)可推断
JNIEnv 代表类型 struct _JNIEnv
JavaVM 代表类型 struct _JavaVM
那么JNIEnv* env实际上等价于声明 struct _JNIEnv* env
JavaVM* vm实际上等价于声明 struct _JavaVM* vm
要调用_JNIEnv结构体内的函数指针这直接使用env而不需间接寻址， env-> GetMethodID(jclass, const char*, const char*)。同理可分析JavaVM* vm。
现在可以回答刚才的猜测了，C中的(*env)类型是const struct JNINativeInterface*，C++中的env类型是struct _JNIEnv*，因此他们的数据类型不相同(虽然都是指针，但指向不同的结构体类型)。
我们再看结构体_JNIEnv(C++的JNIEnv所代表的类型)，这个结构体内有一个成员const struct JNINativeInterface* functions，再仔细看_JNIEnv内定义的函数。当调用_JNIEnv内定义的函数时，其实就是通过functions这个指针调用 JNINativeInterface内的函数指针,因此_JNIEnv的成员方法是JNINativeInterface的同名成员函数指针的包装而 已，归根结底无论在C还是C++中其实都使用了JNINativeInterface结构体。这时调用JNINativeInterface的函数指针的 第一参数是this，在C++中this代表指向当前上下文对象的指针其类型是struct _JNIEnv*（即JNIEnv*）。同理可分析_JavaVM。
2.注册和注销native函数
C和C++注册native函数的方式大致上相同，下面给出具体的代码。
[cpp] view plaincopy
/* JNINativeMethod数组的定义在C和C++中都一样*/
static JNINativeMethod gMethods[] = {
{
"jobjectProcess",
"(Lcom/example/hellojni/HelloJni$Student;Ljava/lang/Integer;)V",
(void*)jobjectProcess
}
/*被省略掉的代码*/
};
jint JNI_OnLoad(JavaVM* vm,void* reserved)
{
JNIEnv* env = NULL;
jint result=-1;
if( (*vm)->GetEnv(vm,(void**)&env , JNI_VERSION_1_4) != JNI_OK)
return result;
jclass HelloJniClazz=(*env)->FindClass(env,"com/example/hellojni/HelloJni");
/* C */
jint r=(*env)->RegisterNatives(env, HelloJniClazz, gMethods, sizeof(gMethods) / sizeof(JNINativeMethod));
/* C++ */
r=AndroidRuntime::registerNativeMethods(env,"com/example/hellojni/HelloJni",gMethods,NELEM(gMethods));
[cpp] view plaincopy
/*或者env->RegisterNatives(HelloJniClazz, gMethods, sizeof(gMethods) / sizeof(JNINativeMethod));*/
if(0 == r)
//注册native函数成功
else
//注册native函数失败
return JNI_VERSION_1_4;
}
void JNI_OnUnload(JavaVM* vm,void* reserved)
{
JNIEnv* env = NULL;
if( (*vm)->GetEnv(vm,(void**)&env , JNI_VERSION_1_4) != JNI_OK)
return;
jclass HelloJniClazz=(*env)->FindClass(env,"com/example/hellojni/HelloJni");
/* C */
jint r=(*env)->UnregisterNatives(env,HelloJniClazz);
/* C++ */
jint r= env->UnregisterNatives(HelloJniClazz)
if(r == 0)
//注销native函数成功
else
//注销native函数失败
}
C和C++中都可以通过JNIEnv的RegisterNatives函数注册，而C++还提供了 AndroidRuntime::registerNativeMethods，AndroidRuntime类的 registerNativeMethods方法也可以注册。
3. 在native中向LogCat输出调试信息
在C/C++编译单元头部加上
#include <android/log.h>
#define LOG_TAG "自定义一个字符串"
log.h声明了函数int __android_log_print(int prio, const char *tag, const char *fmt, ...)我们就是用这个函数向LogCat输出信息的。
加入了头文件后还必须给链接器指定__android_log_print函数所在的库文件liblog.so，在Android.mk文件中加上一行
LOCAL_LDLIBS := -llog
在native函数中可以用如下语句输出了
__android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,"name=%s,age=%d",”卢斌晖”,28);
第一个参数ANDROID_LOG_DEBUG是枚举常量，它在log.h中定义。
[cpp] view plaincopy
typedef enum android_LogPriority
{
ANDROID_LOG_UNKNOWN = 0,
ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */
ANDROID_LOG_VERBOSE,
ANDROID_LOG_DEBUG,
ANDROID_LOG_INFO,
ANDROID_LOG_WARN,
ANDROID_LOG_ERROR,
ANDROID_LOG_FATAL,
ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */
} android_LogPriority;
我们可以根据调试信息的不同类别而选用不同的枚举常量。
4.关于jclass
jclass代表JAVA中的java.lang.Class。我们看jclass的定义，下面给出$NDK\platforms\android-5\arch-arm\usr\include\jni.h的部分代码
[cpp] view plaincopy
#ifdef __cplusplus
/*Reference types, in C++*/
class _jobject {};
class _jclass : public _jobject {}; /*_jclass继承_jobject*/
typedef _jclass* jclass;
#else
/*Reference types, in C.*/
typedef void* jobject;
typedef jobject jclass;
#endif
在C中jclass代表类型void*，在C++中代表类型_jclass*。因此jclass是指针，我们能够在log中输出jclass变量值。
__android_log_print(ANDROID_LOG_DEBUG,"native函数中输出","地址=%p",jclass变量);
当多个native函数都需要使用同一个JAVA类的jclass变量时，不能够定义jclass类型全局变量并只对其赋初值一次然后在多次JAVA对native函数调用中使用这个jclass变量。不能企图以此方式来节约获得jclass变量的开销。
每次JAVA调用native都必须重新获得jclass，上次调用native所得到的jclass在下次调用native时再使用是无效的。下面是C代码
[cpp] view plaincopy
static jclass StudentClazz; //全局变量
jint JNI_OnLoad(JavaVM* vm,void* reserved)
{
JNIEnv* env = NULL;
jint result=-1;
if( (*vm)->GetEnv(vm,(void**)&env , JNI_VERSION_1_4) != JNI_OK)
return result;
StudentClazz=(*env)->FindClass(env,"com/example/hellojni/HelloJni$Student"); //初始化
return JNI_VERSION_1_4;
}
JNIEXPORT void JNICALL jobjectProcess(JNIEnv *env, jobject instance,jobject student,jobject flag)
{
/*StudentClazz=(*env)->FindClass(env,"com/example/hellojni/HelloJni$Student");*/
__android_log_print(ANDROID_LOG_DEBUG,"在jobjectProcess中输出","StudentClazz=%p",StudentClazz);
nameFieldId=(*env)->GetFieldID(env,StudentClazz,"name","Ljava/lang/String;");
jstring name=(jstring)((*env)->GetObjectField(env,student,nameFieldId));
}
下面是Activity的代码
[java] view plaincopy
static
{
System.loadLibrary("hello-jni");
}
public native void jobjectProcess(Student student,Integer flag);
public static class Student{/*省略的代码*/}
protected void onResume()
{
jobjectProcess(new Student(),new Integer(20));
super.onResume();
}
上面的C代码在JNI_OnLoad函数中对StudentClazz初始化，在jobjectProcess函数内没有再对StudentClazz赋值。此时运行程序会出错并在LogCat输出如下信息：
DEBUG/在jobjectProcess中输出(8494): StudentClazz=0x44c0a8f0
WARN/dalvikvm(8286): JNI WARNING: 0x44c0a8f0 is not a valid JNI reference
WARN/dalvikvm(8286): in Lcom/example/hellojni/HelloJni;.jobjectProcess (Lcom/example/hellojni/HelloJni$Student;Ljava/lang/Integer;)V (GetFieldID)
提示StudentClazz所指向的地址（0x44c0a8f0）不是合法的JNI引用。如果把jobjectProcess函数的第一行注释解除掉，再次给StudentClazz赋值程序便正常执行。
其实不管在哪个native函数内得到的StudentClazz值都是相同的，但每次native调用还是必须执行一次FindClass重新给StudentClazz赋值。
5.native的char*和JAVA的String相互转换
首先确保C/C++源文件的字符编码是UTF-8与JAVA的class文件字符编码保持一致。如果C/C++源码含有中文，那么编译出来的so中的中文字符串也保存为UTF-8编码，这样的程序不会产生乱码。
JNI提供了jstring来引用JAVA的String类型变量，如果native函数需要返回 String或者接受String类型参数就必须使用 到jstring。而C/C++用char*引用字符串起始地址，当native函数接到jstring后要转换为char*所指向的字符串才能处理。当 我们处理完char*所指向的字符串又要转换为jstring才能返回给JAVA代码。下面给出转换的方法(下面均是C代码)。
jstring转换为char*使用JNIEnv的const char* GetStringUTFChars(JNIEnv*, jstring, jboolean*)
JNIEnv env=//传入参数 ; jstring name=//传入参数 ;
const char *nameStr=(*env)->GetStringUTFChars(env,name,NULL);
调用完GetStringUTFChars后必须调用JNIEnv的void ReleaseStringUTFChars(JNIEnv*, jstring, const char*)释放新建的字符串。
(*env)-> ReleaseStringUTFChars(env,name, nameStr);
char*转换为jstring使用JNIEnv的jstring NewStringUTF(JNIEnv*, const char*);
jstring newArgName=(*env)->NewStringUTF(env, nameStr);
调用完NewStringUTF后必须调用JNIEnv的void DeleteLocalRef(JNIEnv*, jobject);释放新建的jstring。
(*env)-> DeleteLocalRef(env, newArgName);
