上一篇简单的介绍了JNI，简单的回顾下，java要想调用c/c++代码分为概括分为三步：
1、编写native方法，在c/c++中实现对应的c函数
2、将c代码编译成动态库
3、System.loadLibrary()对动态库进行加载
这一篇重点讲c/c++怎么访问java，为了方便开发环境切换到AndroidStudio，首先需要把AS的ndk环境给配好，详细的配置这里先不讲。AS3.0对ndk的支持已经非常友好了，以前的旧版本是用的makefile来编译动态库，新版本的是Cmake编译，其中差异还是比较大的，旧版本的我以前写过一篇文章，感兴趣可以翻出来看看。
首先，as新建一个工程
把支持c++选项勾选上，这时候如果你没有配好ndk-bound，需要到工程的属性设置里面配置：
配置好以后，as会自动生成一个ndk工程，默认生成一些示例代码，非常的友好。在main/cpp目录中存放的是c/c++代码，MainActivity中自动生成了一些示例代码，可以仿照使用。
这里我们不使用生成的代码，把代码全部干掉，重新开始。
-
c准备工作：在cpp目录下面新建c代码文件native.c，在java下面新建一个java类Man.java
image.png
这时候native方法会爆红，这是因为as没有检测到对应的c函数的实现，用alt+enter快捷键自动生成到native.c中，不得不说as越来越强大了，然后需要在CMakeLists.txt文件中加入我们的c文件
image.png
# native.c
JNIEXPORT jstring JNICALL
Java_com_example_xucong_jnitest_Man_accessField(JNIEnv *env, jclass type) {
return (*env)->NewStringUTF(env, "accessField");
}
JNIEXPORT jstring JNICALL
Java_com_example_xucong_jnitest_Man_stringFromJNI(JNIEnv *env, jobject instance) {
return (*env)->NewStringUTF(env, "stringFromJNI");
}
运行结果:
以上是简单使用。
- c/c++访问java属性
首先看下Man.java这个类的代码
public class Man {
public String name = "Tom";
public native static String accessField();
public native String stringFromJNI();
static {
System.loadLibrary("native-lib");
}
}
这里定义了一个属性、一个静态的native方法accessField()，一个非静态的native方法stringFromJNI(),和一个静态块，用来加载as为我们编译好的so动态库，注意native-lib是as编译好动态库的名称，不包括后缀，当然这个名字我们可以CMakeLists里面修改，编译好的so库在app/build/intermediates/cmake里面
native方法有静态和非静态之分，对应的c的实现函数也有所差异：
NIEXPORT jstring JNICALL
Java_com_example_xucong_jnitest_Man_accessField(JNIEnv *env, jclass type) {
return (*env)->NewStringUTF(env, "accessField");
}
JNIEXPORT jstring JNICALL
Java_com_example_xucong_jnitest_Man_stringFromJNI(JNIEnv *env, jobject instance) {
return (*env)->NewStringUTF(env, "stringFromJNI");
}
c对应的java native函数中至少有两个参数，JNIEnv、jclass或者jobject，JNIEnv是JNI的运行环境，在c中一个二级结构体指针，在c++中是一级指针，他们所调用函数的方式也有不同：
JNIEXPORT jstring JNICALL
Java_com_example_xucong_jnitest_Man_accessField(JNIEnv *env, jclass type) {
return env->NewStringUTF("accessField");
// return (*env)->NewStringUTF(env, "accessField");
}
他们所使用的方法名都是一样，只是c++中的所有函数不在需要传env的上下文了，这是因为c++中有this上下文关键字。
jobject和jclass，这是JNI的数据类型，如果java中是非静态方法，对应的jobject，如果是静态的对应的是jclass，这两个参数是java在JNI中的映射，需要通过这两个参数来访问java。其实也好理解，如果是非静态，我们调用native方法的时候需要new一个对象，和对象实例有关，静态的方法只和Class有关。
函数的返回类型是jstring 对应的java中的String，每种java的数据类型在JNI中都有与之对应
typedef uint8_t jboolean; /* unsigned 8 bits */
typedef int8_t jbyte; /* signed 8 bits */
typedef uint16_t jchar; /* unsigned 16 bits */
typedef int16_t jshort; /* signed 16 bits */
typedef int32_t jint; /* signed 32 bits */
typedef int64_t jlong; /* signed 64 bits */
typedef float jfloat; /* 32-bit IEEE 754 */
typedef double jdouble; /* 64-bit IEEE 754 */
/* "cardinal indices and sizes" */
typedef jint jsize;
#ifdef __cplusplus
typedef _jobject* jobject;
typedef _jclass* jclass;
typedef _jstring* jstring;
typedef _jarray* jarray;
typedef _jobjectArray* jobjectArray;
typedef _jbooleanArray* jbooleanArray;
typedef _jbyteArray* jbyteArray;
typedef _jcharArray* jcharArray;
typedef _jshortArray* jshortArray;
typedef _jintArray* jintArray;
typedef _jlongArray* jlongArray;
typedef _jfloatArray* jfloatArray;
typedef _jdoubleArray* jdoubleArray;
typedef _jthrowable* jthrowable;
typedef _jobject* jweak;
#else /* not __cplusplus */
/*
* Reference types, in C.
*/
typedef void* jobject;
typedef jobject jclass;
typedef jobject jstring;
typedef jobject jarray;
typedef jarray jobjectArray;
typedef jarray jbooleanArray;
typedef jarray jbyteArray;
typedef jarray jcharArray;
typedef jarray jshortArray;
typedef jarray jintArray;
typedef jarray jlongArray;
typedef jarray jfloatArray;
typedef jarray jdoubleArray;
typedef jobject jthrowable;
typedef jobject jweak;
数据类型分为基本数据类型和引用数据类型，引用数据类型分为jstring和jobject，还有任何数组也是jobject，这些都在jni.h源码中有。
那么进入正题：在c层调来修改Man的属性name的值，这里需要把accessField修改为非静态方法，因为name属性是非静态的，只有对象实例才有属性值。
//1.访问属性
//修改属性key的字符串
JNIEXPORT jstring JNICALL
Java_com_example_xucong_jnitest_Man_accessField(JNIEnv *env, jobject jobj) {
//得到class
jclass jclazz = (*env)->GetObjectClass(env,jobj);
//jfieldID
//签名：类型的简称
//属性，方法
jfieldID fid = (*env)->GetFieldID(env,jclazz,"name","Ljava/lang/String;");
//获取key属性的值
//注意：key为基本数据类型，规则如下
//(*env)->GetIntField(); (*env)->Get<Type>Field();
jstring jstr = (*env)->GetObjectField(env,jobj,fid);
//jstring转为 C/C++字符串
char * c_str = (*env)->GetStringUTFChars(env,jstr,NULL);
strcat(c_str,"android");
//拼接完成之后，从C字符串转为jstring
jstring jstr_new = (*env)->NewStringUTF(env,c_str);
//修改key的属性
//注意规则：Set<Type>Field
(*env)->SetObjectField(env,jobj,fid,jstr_new);
return jstr_new;
}
以上的流程和java的反射的流程非常相似，拿到class对象->获取属性id->拿到属性值->修改属性，
-
GetFieldID ，最后一个参数为数据类型的签名，name是String类型，就将String签名传入，各种数据类型的签名如下：
image.png GetObjectField，获取属性值，规则为Get<Type>Field，如果java类中的属性类型为int，则为GetIntField()；
Get<Type>Field();修改属性的值，和GetObjectField的规则一样。
其中要注意的是jni的字符串是没有修改的api的，需要通过c字符串来修改，再改回jstring。
java代码：
TextView tv = findViewById(R.id.sample_text);
Man man = new Man();
String str = "修改前：" + man.name;
man.accessField();
str = str + " 修改后：" + man.name;
tv.setText(str);
运行结果：
- 访问java静态属性
访问java静态属性的步骤，只是api稍有调整
在Man.java中增加一个属性，和一个方法
public static int age = 18;
public native String accessStaticField();
c代码：
Java_com_example_xucong_jnitest_Man_accessStaticField(JNIEnv *env, jobject jobj) {
//获取class
jclass jclazz = (*env)->GetObjectClass(env,jobj);
//获取jfieldid
jfieldID jid = (*env)->GetStaticFieldID(env,jclazz,"age","I");
jint jage = (*env)->GetStaticIntField(env,jclazz,jid);
jage++;
(*env)->SetStaticIntField(env,jclazz,jid,jage);
return (*env)->NewStringUTF(env, "修改成功");
}
java代码：
TextView tv = findViewById(R.id.sample_text);
Man man = new Man();
String str = "name修改前：" + man.name;
man.accessField();
str = str + "\nname修改后：" + man.name;
str += "\nage修改前：" + Man.age;
man.accessStaticField();
str = str + "\nage修改后：" + Man.age;
tv.setText(str);
可以看出来，步骤和前面一样，只是访问静态属性的方法都加上了static
另外就是SetStaticIntField()方法的第二个参数类型是jclass，而不是jobject，为什么呢？这个和java的类是对应的，我们访问java的静态变量的时候，变量只和Class有关，和实例对象的应用无关，而非静态成员变量和必须要通过对象的引用来访问，在JNI中也是这个理。如果accessStaticField()方法改为static，那么JNI中实现的c方法为jclass对象可以省去jclass jclazz = (*env)->GetObjectClass(env,jobj);这一步骤。
- C/C++D调用java方法
直接上代码：
public native int accessMethod();
public int getRandomNum(int max) {
return new Random().nextInt(max);
}
accessMethod()方法是进入c，c/c++中再去调用getRandomNum产生随机数，返回给accessMethod()方法。
看看JNI的实现：
//访问java方法
JNIEXPORT jint JNICALL
Java_com_example_xucong_jnitest_Man_accessMethod(JNIEnv *env, jobject jobj) {
//获取class
jclass jclazz = (*env)->GetObjectClass(env,jobj);
jmethodID jmid = (*env)->GetMethodID(env,jclazz,"getRandomNum","(I)I");
jint random = (*env)->CallIntMethod(env,jobj,jmid,100);
return random;
}
步骤套路和前面及其的相似，不同的只是方法的调用，GetMethodID获取方法id，方法第三个参数为方法名，最后一个参数是方法签名，方法签名为对应的是jobj的java类的签名。
获取签名：
获取签名是用javap命令，打开as的terminal 可以看到javap的指令集
cd 到app/build/intermediates/debug目录下，里面有编译好的class文件，执行javap -p -s com.example.xucong.jnitest.Man指令，就能够获取参数、方法的签名，前面获取成员变量的签名的时候也可以通过这种方式：
其实这些步骤也是也可以偷懒的，可以参考我AS NDK环境变量配置的文章的末尾片段。
public native int accessStaticMethod(String filepath);
//获取uuid随机文件名
public static String getUUID() {
return UUID.randomUUID().toString();
}
//访问静态方法
//借用java api 产生一个UUID字符串，作为文件的名称
JNIEXPORT jint JNICALL
Java_com_example_xucong_jnitest_Man_accessStaticMethod(JNIEnv *env, jobject jobj, jstring jstr_file_path) {
jclass jclazz = (*env)->GetObjectClass(env,jobj);
jmethodID jmid = (*env)->GetStaticMethodID(env,jclazz,"getUUID","()Ljava/lang/String;");
jstring jstr_uuid = (*env)->CallStaticObjectMethod(env,jclazz,jmid);
char *cstr_uuid = (*env)->GetStringUTFChars(env,jstr_uuid,JNI_FALSE);
char *cstr_file_path = (*env)->GetStringUTFChars(env,jstr_file_path,JNI_FALSE);
char filename[100];
sprintf(filename,cstr_file_path,cstr_uuid);
FILE *fp = fopen(filename,"w");
fputs(filename,fp);
fclose(fp);
}
java ：
String path = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "%s.txt";
man.accessStaticMethod(path);
注意：6.0需要动态权限
