什么是JNI?

JNI Java Native Interface java本地接口

JNI 能够解决什么问题？

在 java 面世之前，很多代码都是使用 c/c++ 编写的，在 java 面世后为了避免重复造轮子，并且可以让 java 使用之前编写的 c/c++ 代码，这样就出现了 JNI 这门技术，它是一个 java 和 native 进行相互调用的中间人。

因为有些功能使用 java 代码编写可能会有性能问题，并且反编译代码的安全性问题，因此在某些情况下就需要使用 c/c++ 来配合 java 来开发了。

Java层是如何使用JNI？

Java 层调用 JNI 层的方法需要做两件事

• 加载动态库。
• 使用 native 关键字声明与 JNI 层对应的函数。

如何加载动态库？

理论上是在任何需要调用 native 代码的地方之前就可以去加载动态库，但是一般情况下都会在类的 static 代码块中去加载。

System.loadLibrary("动态库的名称")

动态库的名称，例如 media_jni，系统会自动根据不同的平台拓展成真实的动态库文件名，例如在Linux系统上会拓展成libmedia_jni.so，而在Windows平台上则会拓展成media_jni.dll。

Native 和 JNI 层的代码怎么相互对应呢？

• MediaScanner 类定义的 native_init 方法 是在这个路径下：android.media.MediaScanner.native_init

• JNI 层的代码 : android_media_MediaScanner_native_init

jni 方法的命名规则：Java_包名类名方法名

JNI函数的注册问题

什么叫做注册？

就是将 Java 层的函数和 JNI 层的函数关联起来。

函数注册分为两种方式：静态注册\动态注册

一、静态注册

• 在 Java 层使用 native 关键字描述函数

  public class Utils {
    public static native int add(int a, int b);
  }
  

• 根据在 Utils 类编写的 add 函数生成对应的 native 函数。

    //javah 是 jdk 提供的一个工具
    //在终端使用 cd 切换到 Utils 编译后的文件目录下，具体位置看下面的截图，不要搞错地方，否则会出现找不到Utils类
    //-o Utils.h 表示输出的文件名为 Utils.h
    javah -o Utils.h com.lu.ndkdemo.Utils
  
    //生成文件的路径：app/build/intermediates/classes/debug/com/lu/ndkdemo/Utils.class
  
  

• 过程：编写 Java 代码 -> 编译 -> 使用 javah 命令生成 packageName_class.h 头文件

   javah -o output packgeName.className
  

• 生成对应的 Utils.h 文件

  /* DO NOT EDIT THIS FILE - it is machine generated */
  #include <jni.h>
  /* Header for class com_lu_ndkdemo_Utils */
  
  #ifndef _Included_com_lu_ndkdemo_Utils
  #define _Included_com_lu_ndkdemo_Utils
  #ifdef __cplusplus
  extern "C" {
  #endif
  /*
   * Class:     com_lu_ndkdemo_Utils
   * Method:    add
   * Signature: (II)I
   */
  JNIEXPORT jint JNICALL   Java_com_lu_ndkdemo_Utils_add
  (JNIEnv *, jclass, jint, jint);
  
  #ifdef __cplusplus
  }
  #endif
  #endif
  
  

• native 函数是如何寻找 JNI 函数的？
  当Java层调用native_init函数时，它会从对应的JNI库Java_android_media_MediaScanner_native_init，如果没有，就会报错。如果找到，则会为这个native_init和Java_android_media_MediaScanner_native_init 建立一个关联关系，其实就是保存JNI层函数的函数指针。以后再调用native_init函数时，直接使用这个函数指针就可以了，当然这项工作是由虚拟机完成的。

• 将 Utils.h 文件拷贝到存放 native 代码的文件夹中

我的工程存放 native 代码的目录是 main/cpp/
所以将生成 Utils.h 拷贝到 main/cpp 即可

• 编写 native 层的代码，我将其命名为 test.c

  //引入刚才生成的 Utils.h 文件
  #include "Utils.h"
  #include <android/log.h> 
  //将 Utils.h 生成函数拷贝到test.c 中
  //注意拷贝过来的函数是不完整的，需要手动添加参数变量名
  JNIEXPORT jint JNICALL   Java_com_lu_ndkdemo_Utils_add
        (JNIEnv *env, jclass obj, jint a, jint b) {
   //返回计算结果
   return a + b;
  }
  

• 接下来就在 java 层代码加载 so 库，并且调用该方法即可，这一步就忽略不写。

二、动态注册

为什么有了静态注册之后还要有一个动态注册的功能呢？

我们看到了，在静态注册中，我们使用了 javah 生成对应 native 函数，可以看出它的方法名是非常的长的，因此为了简化这个方法的表示，就有了动态注册。
动态注册的原理是这样的：JNI 允许我们提供一个函数映射表，注册给 JVM，这样 JVM 就可以用函数映射表来调用相应的函数，而不必通过函数名来查找相关函数(这个查找效率很低，函数名超级长)。

• 在 Java 层使用 native 关键字描述函数

public class Utils {
   public static native int add(int a, int b);
}

• 在哪里告诉系统我要动态注册函数呢？

我们都知道 java 想要调用 c 层的代码，主要分 2 步：

1. System.loadLibrary("so name");

2. 调用对应的 native 代码
   int result = Utlils.add(1,2);

现在我们需要找到一个时机告诉系统，我要动态注册函数，并且告诉系统怎么动态注册。

而系统在执行完 System.loadLibrary("..")之后会执行 native 层的 JNI_Onload 方法，因此我们只需要在该方法完成动态注册即可。

• 在 JNI_Onload 函数动态注册

想要进行动态注册，就必须要有一个 java 层函数和 native 函数的对应关系表。

在 jni 中是使用 JNINativeMethod 来保存对应关系

typedef struct {
  char *name;//
  char *signature;
  void *fnPtr;
} JNINativeMethod;

编写对应关系表
method_table 是一个数组，它存放就是 JNINativeMethod 定义的三个属性参数。

1. name java 层的方法名
2. signature 方法的签名
3. fnPtr 对应的 native 的方法名

//下面这段代码的表示就是将 java 层的 add 方法映射
//到 native 层的 add 方法，不再是静态注册那种很长的方法名了。
static JNINativeMethod method_table[] = {
{
"add", "(II)I",(void *) add}
};

有了对应关系表 method_table 之后，我们就要开始注册了。下面的 JNI_Onload 方法就是对 method_table 表进行动态注册。因此只需要实现这个方法，在方法内部进行动态注册即可。在动态加载 so 库之后，系统会调用 jint 。

/**
 * 动态注册
 * 在 native 代码中重写该 JNI_Onload 方法即可
 */
JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    //OnLoad方法是没有JNIEnv参数的，需要通过vm获取。
    JNIEnv *env = NULL;
    jint result = -1;

    if ((*vm)->GetEnv(vm, (void **) &env, JNI_VERSION_1_4) != JNI_OK) {
        return -1;
    }
    //获取对应声明native方法的Java类
    jclass clazz = (*env)->FindClass(env, "com/lu/ndkdemo/Utils");
    if (clazz == NULL) {
        return JNI_FALSE;
    }
    //注册方法，成功返回正确的JNIVERSION。
    if ((*env)->RegisterNatives(env, clazz, method_table,
                                sizeof(method_table) / sizeof(method_table[0])) == JNI_OK) {
        return JNI_VERSION_1_4;
    }
    return JNI_FALSE;
}

jni 的方法签名

• Java 层的 native 方法：

private native void processFile(String path, String mimeType, MediaScannerClient client);

格式：(参数类型...)函数返回值类型

(Ljava/lang/String;Ljava/lang/String;Landroid/media/MediaScannerClient;)V

• 签名的相关解释
  • L 开头表示该参数是引用数据类型
  • 参数类型使用包/类名表示
  • 每一个引用类型使用;结束
  • 最右边表示该方法的返回值类型
    • V 表示没有返回值 void类型

如何将 jni 层的函数和 native 函数一一对应呢？

一、通过JNINativeMethod一一对应
在 jni.h 文件中声明了一个叫 JNINativeMethod 的结构体，通过这个结构体就可以将 native 函数和 jni 函数进行一一对应了。

/*
 * used in RegisterNatives to describe native method name, signature,
* and function pointer.*/
typedef struct {
    char *name;
    char *signature;
    void *fnPtr;
} JNINativeMethod;

二、如何使用 JNINativeMethod?

• 1、定义一个 nativeMethod 数组

  JNINativeMethod nativeMethod[] = {
      {"processFile", //native函数名称
      "(//函数参数类型
            Ljava/lang/String;
            Ljava/lang/String;
            Landroid/mediaMediaScannerClient;
         )
         V//函数返回值类型
         ",      (void*)android_media_MediaScanner_processFile  // jni 层函数名称
           }
          };
  

  static JNINativeMethod gMethods[] = {
    {"_start","()V",(void   *)android_media_MediaPlayer_start}
            ...
  }
  

• 2、动态注册数组 registerNativeMethods

  static int   register_android_media_MediaPlayer(JNIEnv *env){
    //向 VM 进行注册
    return   AndroidRuntime::registerNativeMethods(env,
                "android/media/MediaPlayer", gMethods, NELEM(gMethods));
  }
  
   int   AndroidRuntime::registerNativeMethods(JNIEnv*env,
    constchar* className, const JNINativeMethod* gMethods, int numMethods){
    //调用jniRegisterNativeMethods函数完成注册
    return jniRegisterNativeMethods(env, className, gMethods, numMethods);}   
  int jniRegisterNativeMethods(JNIEnv* env, const char* className,const JNINativeMethod* gMethods, int numMethods){
    jclassclazz;
    clazz= (*env)->FindClass(env, className);
    ...
    //实际上是调用JNIEnv的RegisterNatives函数完成注册的
    //gMethods = sizeof(methods) / sizeof(methods[0]))
    if((*env)->RegisterNatives(env, clazz, gMethods) numMethods) < 0) {
       return -1;
  
    }
  
    return0;
  
  }    
  

其实最终都是调用 RegisterNatives 方法完成注册功能的。

数据类型转化

1、基本数据类型转化
2、引用数据类型转化

除了Java中基本数据类型的数组、Class、String和Throwable外，其余所有Java对象的数据类型在JNI中都用jobject表示。

processFile(String path, String mimeType,MediaScannerClient client);

android_media_MediaScanner_processFile(JNIEnv*env, jobject thiz,jstring path, jstring mimeType, jobject client)

在 JNI 层的 processFile 的第二参数的说明：表示的是调用 processFile 方法的 MediaScanner 对象，如果该方法是 static 方式的话，那么该参数就是 jclass 类型的，表示的是调用哪个类调用静态函数 processFile 。

JNIEnv 的介绍

在 JNI 层的 processFile 函数声明中可以看到第一个参数就是 JNIEnv* 类型的，那么这个类型表示的是什么意思呢？

JNIEnv*是定义任意native函数的第一个参数（包括调用JNI的RegisterNatives函数注册的函数），用于访问JVM数据结构的JNI函数表指针。

通过 JNIEnv 操作 jobject

能通过 JNIEnv 操作 jobject 就实际上就是通过 JNIEnv 操作 jobject 中的属性和方法。

• JNIEnv 操作 jobject 的属性
• JNIEnv 操作 jobject 的方法

JNI 是如何定义 jobject 的属性和方法的？

jfieldID GetFieldID(jclass clazz,const char*name, const char *sig);

jmethodID GetMethodID(jclass clazz, const char*name,const char *sig);

//得到java对象
jclass mediaScannerClientInterface = env->FindClass("android/media/MediaScannerClient");

//找到该对象的方法id
mScanFileMethodID = env->GetMethodID(mediaScannerClientInterface, "scanFile","(Ljava/lang/String;JJ)V");

// env
//jobject 要操作的java对象，可以通过 FindClass 获取
//methodID 表示该方法的id，可以通过 GetMethodID 获取
NativeType Call<type>Method(JNIEnv *env,jobject obj,jmethodID methodID, ...)。
jboolean CallBooleanMethod(jobject obj,jmethodID methodID, ...) 

mEnv->CallBooleanMethod

//得到对象的属性值
// env
//jobject 要操作的java对象，可以通过 FindClass 获取
//fieldID 表示该属性的id，可以通过 GetFieldID 获取
jboolean(jni对应的类型) GetBooleanField(Get<type>Field)(jobject obj, jfieldID fieldID) {
        return functions->GetBooleanField(this,obj,fieldID);
}
//设置对象的属性值
 void Set<type>Field(jobject obj, jfieldID fieldID,jboolean val) {
        //const struct JNINativeInterface_ *functions
        functions->SetBooleanField(this,obj,fieldID,val);
}

jstring

jstring NewString(const jchar *unicode, jsize len) {
        return functions->NewString(this,unicode,len);
}

GetStringChars得到一个Unicode字符串

const jchar *GetStringChars(jstring str, jboolean *isCopy) {
        return functions->GetStringChars(this,str,isCopy);
    }

jstring NewStringUTF(const char *utf) {
        return functions->NewStringUTF(this,utf);
}

GetStringUTFChars得到一个UTF-8字符串。

const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
        return functions->GetStringUTFChars(this,str,isCopy);
}

void ReleaseStringChars(jstring str, const jchar *chars) {
        functions->ReleaseStringChars(this,str,chars);
}

void ReleaseStringUTFChars(jstring str, const char* chars) {
    functions->ReleaseStringUTFChars(this,str,chars);
}

使用 jstring

android_media_MediaScanner_processFile(JNIEnv*env, jobject thiz, jstring path, jstring mimeType, jobject client) {
    //调用JNIEnv的GetStringUTFChars得到本地字符串pathStr
    const char *pathStr = env->GetStringUTFChars(path, NULL);

    //使用完后，必须调用ReleaseStringUTFChars释放资源
    env->ReleaseStringUTFChars(path, pathStr);
}

JNI类型签名

示例

"(Ljava/lang/String;Ljava/lang/String;Landroid/media/MediaScannerClient;)V",   

• (参数1类型标示参数2类型标示...参数n类型标示)返回值类型标示
• L 表示该参数是引用类型的；
• 参数类型使用权限类名表示，不过.需要替换为/
• 在引用类型后面需要使用;结尾
• 最右边V表示没有返回值

工具的使用

虽然函数签名信息很容易写错，但Java提供一个叫javap的工具能帮助生成函数或变量的签名信息，它的用法如下：

javap –s -p xxx。其中xxx为编译后的class文件，s表示输出内部数据类型的签名信息，p表示打印所有函数和成员的签名信息，而默认只会打印public成员和函数的签名信息。

垃圾回收

• Local Reference

  LocalReference最大的特点就是，一旦JNI层函数返回，这些jobject就可能被垃圾回收。

• Global Reference

  全局引用，这种对象如不主动释放，就永远不会被垃圾回收。

• WeakRe Global ference

• 变量的内存释放

  void DeleteLocalRef(jobject obj) 
  mEnv->DeleteLocalRef(pathStr); 
  

JNI 异常处理

当调用 JNIEnv 的某些函数出错后，不会向 Java 一样会终止下一行代码的执行，直到从 JNI 层返回到 Java 层后，虚拟机才会抛出这个异常。

出现异常后，不能再调用 JNIEnv 的函数了，不然程序就会挂掉。

JNI层函数可以在代码中截获和修改这些异常，JNIEnv提供了三个函数进行帮助：

• ExceptionOccured函数，用来判断是否发生异常。

• ExceptionClear函数，用来清理当前JNI层中发生的异常。

• ThrowNew函数，用来向Java层抛出异常。

在jni层打log日志

• 引入 #include <android/log.h> 头文件
• 声明

#define  LOG  "JNILOG" // 这个是自定义的LOG的TAG
#define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG,__VA_ARGS__) // 定义LOGD类型
#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG,__VA_ARGS__) // 定义LOGI类型
#define  LOGW(...)  __android_log_print(ANDROID_LOG_WARN,LOG,__VA_ARGS__) // 定义LOGW类型
#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG,__VA_ARGS__) // 定义LOGE类型
#define LOGF(...)  __android_log_print(ANDROID_LOG_FATAL,LOG,__VA_ARGS__) // 定义LOGF类型

• 使用

jint i = 3;
LOGE("i = %d\n",i ));

总结

1. JNI 函数的注册
2. JNI 和 Java 的类型转换
3. JNIEnv 的含义及其作用
4. jstring 的使用
5. JNI 的签名
6. JNI 的垃圾回收
7. JNI 的异常处理

注意事项

在java类中编写 native 方法。注意这时方法本身会报红，只要按 command+enter 就可以直接生成一个与之对应的 jni 方法。

package com.lu.ndkdemo2;
/**
 * Created by anlu on 2017/11/25.
 */
public class Utils {
    public native void call(String name,int age,String[] args);
}

编译：build->rebuild

找到 /Users/lu/dev/as_code/NDKDemo2/app/build/intermediates/classes/debug

javah -jni com.lu.ndkdemo2.Utils 生成的文件名就是 com_lu_ndkdemo2_Utils.h
javah -o test.h com.lu.ndkdemo2.Utils 生成的文件名就是 test.h
即可生成对应的头文件

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_lu_ndkdemo2_Utils */

#ifndef _Included_com_lu_ndkdemo2_Utils
#define _Included_com_lu_ndkdemo2_Utils
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_lu_ndkdemo2_Utils
 * Method:    call
 * Signature: (Ljava/lang/String;I[Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_com_lu_ndkdemo2_Utils_call
  (JNIEnv *, jobject, jstring, jint, jobjectArray);

#ifdef __cplusplus
}
#endif
#endif

路径在：/Users/lu/dev/as_code/NDKDemo2/app/build/intermediates/classes/debug

#include <jni.h>
#include <string>

JNIEXPORT void JNICALL
Java_com_lu_ndkdemo2_Utils_call(JNIEnv *env, jobject instance, jstring name_, jint age,
                                  jobjectArray args) {
    const char *name = env->GetStringUTFChars(name_, 0);
    // TODO
    //释放jstring
    env->ReleaseStringUTFChars(name_, name);
}

JNIEXPORT，JNICALL：是系统定义的宏；
JNIEXPORT后面写函数的输出类型；
JNICALL后面写函数名，实测这两个宏可写可不写。

No implementation found for int com.lu.ndkdemo.Utils.add(int, int) (tried Java_com_lu_ndkdemo_Utils_add and Java_com_lu_ndkdemo_Utils_add__II)

1.方法没有使用extern C 表示，会报不到异常。
2.没有写system.loadLibrary("")。

couldn't find "libtest.so"，没有在 CMakeLists.txt 声明。

一个so可以构建多个源文件
add_library(<name> [STATIC | SHARED | MODULE][EXCLUDE_FROM_ALL] source1 [source2 ...])
name 就是打包的 so 库的名称。
so 库一般会使用 SHARED。source1、 source2 多个source直接用空格即可，不可以用,在 CMakeLists.txt 指定多个子CMakeLists.txt 构建多个 so 库。

 #set(<variable> <value> [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])
 #add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

如果在c/c++代码打log日志
异常情况：

11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 我是log3
11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 执行了java层的callExceptionMethod方法
11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 没有异常的情况...
11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 没有异常的情况...
11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 没有异常的情况...
11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 没有异常的情况...
11-25 12:30:13.106 3165-3165/com.lu.ndkdemo E/JNILOG: 没有异常的情况5...
11-25 12:30:13.107 3165-3165/com.lu.ndkdemo E/zeal: java 层出现异常...JNI层抛出了异常...