一、笔记
1.JNI(Java Native Interface),就是如何使用java去访问C/C++编写的那些库。
若想深入了解JNI可以看官方文档jni.pdf。
优秀博文：
Android JNI知识简介：http://blog.****.net/linweig/article/details/5417319
Android JNI(实现自己的JNI_OnLoad函数)：http://jjf19850615.blog.163.com/blog/static/356881472013342153912 (这个看不了了)
2.JNI协议作用位置
Java Android是通过Java写的
---------------
JNI JNI是Java调用C/C++库的协议
---------------
C/C++ App、C库 可以直接系统调用
---------------
驱动 Linux
3.JNI的实现步骤：
(1) 加载C库
(2) 建立java函数与C函数的映射，有两种建立方法，分别为显式建立和隐式建立
(1)显式建立：使用(*env)->RegisterNatives()注册。
(2)隐式建立：如果java源文件中类a.b.c.d.JNIDemo要调用hello(),那么C源文件中要实现Java_a_b_c_d_JNIDemo_hello()这个函数，
函数名要严格对应。对应的C中的函数的函数名同样可以使用javah来生成。
使用隐式建立时C源文件中就不需要再定义JNI_OnLoad()了。
但是一般倾向于建立显式建立，因为比较灵活。
(3) 调用C函数
4.jni.h文件
可以通过它来看env中提供的函数的函数签名，其路径：/usr/lib/jvm/java-1.7.0-openjdk-amd64/include/jni.h
注意：需要使用-I指定jni.h的路径名以便#include可以包含的到它。
5.JNI的字段描述符
用于描述C源文件中的JNINativeMethod.signature字段
①参数中的数组使用[表示，例如int[] a为[I
②对于类要用全称“L包.子包.类名;”（前面有L后面有;），eg："Ljava/lang/String;"
除了String类之外的其它所有类都要使用“L/java/lang/Object”来表示。
对于类参数和返回值都是一样的表示。
也可以使用一个取巧的办法，使用javah生成一个JNIDemo.h头文件，这个头文件中就有这些描述符。
$ javac JNIDemo.java
$ javah -jni JNIDemo
6.JNI传递参数
(1) 基本类型的参数传递非常简单，java传给C文件的参数C文件中直接使用就可以了。对基本类型的参数传递是透明的。
(2) 参数或返回值是类名时对应C中的函数签名可以借助javah来查看
①对于字符串类的双向传递需要使用env中的一些函数。参考jni.pdf pg39,
②传递数组时C文件中的函数签名可以参考javah生成的头文件。参考jni.pdf pg48
7.java函数映射的C文件中的函数前面的修饰JNICALL是一个空的宏，写不写无所谓。
8.java文件怎样使用native函数总结
java文件中声明native方法，然后在类的静态代码块中调用System.loadLibrary("本地库")来加载本地库，这会触发本地库中的onLoad()被调用。
本地需要实现java类中的native方法，并在onLoad()中将这些方法注册到java类中。此后java就可以调用本地方法了。
二、Java调用C函数的例子
1.基本实现框架
/*file: JNIDemo. java*/
public class JNIDemo {
/*
* 一般来说会在静态代码块里来加载这个库。因为一
* 个静态代码块会在构造一个对象之前执行，并且只
* 执行一次。
* 它会导致C中实现的JNI_OnLoad()被调用。
*/
static { /* 1. load */
System.loadLibrary("native"); /* 加载libnative.so这个C库 */
}
/*
* 加native关键字修饰表示hello()是定义在C文件中的，
* 这里只是简单的修饰就可以调用了。注意：hello()前
* 没有加static,因此需要创建一个实例化对象调用hello()
*/
public native int hello(int a);
public static void main (String args[]) {
JNIDemo d = new JNIDemo(); /*创建JNIDemo类的对象d*/
/* 2. map java hello <-->c c_hello */ /*hello()是在java中实现的，c_hello()是在C中实现的,映射关系的建立是在C中建立的(显式映射)*/
/* 3. call */
System.out.println(d.hello());
}
}
/* 非static 函数需要通过对象来调用，static可以直接调用*/
public class JNIDemo {
static { /* 1. load */
System.loadLibrary("native"); /* 加载libnative.so这个C库 */
}
public native static void hello(); /*加native关键字修饰表示hello()是定义在C文件中的，这里知识简单的修饰就可以调用了*/
public static void main (String args[]) {/* 2. map java hello <-->c c_hello */
/* 3. call */
hello(); /*与上一个不同，上面申明hello()时加了static修饰，所以这里可以直接调用*/
}
}
/*file: native.c*/ /*
* jni.h位于/usr/lib/jvm/java-1.7.0-openjdk-amd64/include/目录下，
* --sysroot指定这个路径，因此编译C程序时需要指定：
* -I/usr/lib/jvm/java-1.7.0-openjdk-amd64/include/
*/
#include <jni.h>
#include <stdio.h> #if 0
typedef struct {
char *name; /* 这个name就是在Java里调用的函数名，此列子为hello */
char *signature; /* JNI字段描述符, 用来表示Java里调用的函数的参数和返回值类型 */
void *fnPtr; /* C语言实现的本地函数的函数指针 */
} JNINativeMethod;
#endif
jint c_hello(JNIEnv *env, jobject obj, jint a) {
printf("Hello JNI, a=%d\n", a);
return 222;
}
/*
* 既然methods[]是个数组就说明可以同时注册多个本地函数
*/
static const JNINativeMethod methods[] = {
/*
* 本地定义的这个c_hello(除了env和cls)没有参数，
* 所以signature字段中‘()’里面为空，返回值是void
* 所以是"()V". 没有参数是指在java中调用这个函数没有参数。
* 函数签名的写法补充：
* 参数中的数组使用[表示，例如int[] a为[I
* 对于类要用全称“L包.子包.类名;”（前面有L后面有;），eg："Ljava/lang/String;"
* 除了String类之外的其它所有类都要使用“L/java/lang/Object”来表示。
* 对于类参数和返回值都是一样的表示。
*/
{"hello", "(I)I", (void *)c_hello},
};
/* java程序中执行System.loadLibrary()加载这个C库的时候
* 就会先执行C库中定义的JNI_OnLoad(),因此需要在这个函数中
* 建立映射关系。
* 这个函数怎么写参考jni.pdf pg117
*/
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *jvm, void *reserved)
{
JNIEnv *env;
jclass cls; /*
* 获取java程序的运行环境，因为之后需要通过env调用FindClass
* 等函数。
* JNI有1.1 1.2 1.4这几个版本，最后还要返回这个版本，1.1是最
* 老的。
*/
if ((*jvm)->GetEnv(jvm, (void **)&env, JNI_VERSION_1_4)) { /*获取运行环境*/
return JNI_ERR; /* JNI version not supported */
} /*
* java中的函数是通过类来写的。C中的c_hello()要映射
* 到JNIDemo中声明的hello()上，所以要先查找这个类。
*/
cls = (*env)->FindClass(env, "JNIDemo");
if (cls == NULL) {
return JNI_ERR;
} /*
* 建立映射关系，cls是通过java程序获取到的，methods是
* C程序中的。
* methods数组中的数组项只有1项。
*/
/* 2. map java hello <-->c c_hello */
if ((*env)->RegisterNatives(env, cls, methods, ) < )
return JNI_ERR; return JNI_VERSION_1_4;
}
上面是显式映射的例子，下面是隐式映射：
/*file: native.c*/ #include <stdio.h>
#include <jni.h> JNIEXPORT jint JNICALL Java_JNIDemo_hello(JNIEnv *env, jobject obj, jint a) {
printf("Hello JNI, a=%d\n", a);
return ;
}
编译运行方法：
javac JNIDemo.java
gcc -I/usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -fPIC -shared -o libnative.so native.c
export LD_LIBRARY_PATH=.
java JNIDemo 注意：
.编译成C库的操作中若没有加-fPIC会报错“Couldn't read symbols”.
.需要设置环境变量LD_LIBRARY_PATH，否则“no native in java.library.path”
2.双向传递字符串
JNIDemo.java中修改如下:
public class JNIDemo {
static { // 1. load
System.loadLibrary("native");
}
public native String hello(String str); //still is int in java, but jint in C
public static void main(String args[]) {
JNIDemo d = new JNIDemo();
System.out.println(d.hello("Hello JNI String!"));
}
}
native.c中修改如下:
jstring c_hello(JNIEnv *env, jobject cls, jstring str) {
const jbyte *cstr;
cstr = (*env)->GetStringUTFChars(env, str, NULL);
printf("Get string from java :%s\n", cstr);
(*env)->ReleaseStringUTFChars(env, str, cstr);
return (*env)->NewStringUTF(env, "return from c");
}
static const JNINativeMethod methods[] = {
{"hello", "(Ljava/lang/String;)Ljava/lang/String;", (void *)c_hello},
};
3.双向传递数组
/*file: JNIDemo.java*/
public class JNIDemo {
static { // 1. load
System.loadLibrary("native");
}
public native int[] hello(int[] arr);
public static void main(String args[]) {
JNIDemo d = new JNIDemo();
int[] arr = {1, 2, 3};
int[] b = null;
int i;
b = d.hello(arr);
for (i = 0; i < b.length; i++)
System.out.println(b[i]);
}
}
/*file: native.c*/ #include <stdio.h>
#include <stdlib.h>
#include <jni.h> jintArray c_hello(JNIEnv *env, jobject cls, jintArray arr)
{
jint *carr;
jint *oarr;
jintArray rarr; jint i, n = ;
carr = (*env)->GetIntArrayElements(env, arr, NULL);
if (carr == NULL) {
return ; /* exception occurred */
} n = (*env)->GetArrayLength(env, arr);
oarr = malloc(sizeof(jint) * n);
if (oarr == NULL) {
(*env)->ReleaseIntArrayElements(env, arr, carr, );
return ;
} for (i = ; i < n; i++) {
oarr[i] = carr[n--i];
} (*env)->ReleaseIntArrayElements(env, arr, carr, ); /* create jintArray */
rarr = (*env)->NewIntArray(env, n);
if (rarr == NULL) {
return ;
} (*env)->SetIntArrayRegion(env, rarr, , n, oarr);
free(oarr); return rarr;
} static const JNINativeMethod methods[] = {
{"hello", "([I)[I", (void *)c_hello},
}; JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env;
jclass cls; if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_4)) {
return JNI_ERR; /* JNI version not supported */
} cls = (*env)->FindClass(env, "JNIDemo");
if (cls == NULL) {
return JNI_ERR;
} /* 2. map java hello <-->c c_hello */
if ((*env)->RegisterNatives(env, cls, methods, ) < )
return JNI_ERR; return JNI_VERSION_1_4;
}
三、相关资源收集
1. WDS JNIDemo源码：$ git clone https://github.com/weidongshan/JNIDemo.git
四、补充
1.$ java -verbose:jni StaticMethodCal 可以看出JNI库加载的信息
2. 签名中使用的是具体的类名
// frameworks/base/core/jni/android_hardware_SensorManager.cpp
static JNINativeMethod gSystemSensorManagerMethods[] = {
{"nativeClassInit", "()V", (void*)nativeClassInit },
/*L+包名+类名*/
{"nativeGetNextSensor", "(Landroid/hardware/Sensor;I)I", (void*)nativeGetNextSensor },
};
static JNINativeMethod gBaseEventQueueMethods[] = {
{"nativeInitBaseEventQueue",
/*类的内部类直接使用"$"连接*/
"(Landroid/hardware/SystemSensorManager$BaseEventQueue;Landroid/os/MessageQueue;[F)J",
(void*)nativeInitSensorEventQueue },
};