Android之 JNI详解
一、JNI简介
JNI 是Java Native Interface的缩写,表示Java本地调用,通过JNI技术可以实现Java调用C程序和C程序调用Java代码。
二、JNI函数注册
2.1 静态注册:
- 静态注册的方式我们平时用的比较多。我们通过javac和javah编译出头文件,然后再实现对应的cpp文件的方式就是属于静态注册的方式。这种调用的方式是由于JVM按照默认的映射规则来匹配对应的native函数,如果没匹配,则会报错。
- 优缺点: 系统默认方式,使用简单; 灵活性差(如果修改了java native函数所在类的包名或类名,需手动修改C函数名称(头文件、源文件))
//Java 层代码JniSdk.java
public class NativeDemo {
static {
System.loadLibrary("jnisdk");
}
public native String showJniMessage();
}
//Native层代码 jnidemo.cpp
extern "C"
JNIEXPORT jstring JNICALL Java_com_dong_example_JnidemoClass_showJniMessage
(JNIEnv* env, jobject job) {
return env->NewStringUTF("hello world");
}
JNIEXPORT :在Jni编程中所有本地语言实现Jni接口的方法前面都有一个"JNIEXPORT",这个可以看做是Jni的一个标志,至今为止没发现它有什么特殊的用处。
jstring :这个学过编程的人都知道,当然是方法的返回值了,对应java的String类型,无返回值就是void
JNICALL :这个可以理解为Jni 和Call两个部分,和起来的意思就是 Jni调用XXX(后面的XXX就是JAVA的方法名)。
Java_NativeDemo_sayHello:这个就是被上一步中被调用的部分,也就是Java中的native 方法名:包名+类名+方法名。
JNIEnv * env:这个env可以看做是Jni接口本身的一个对象,jni.h头文件中存在着大量被封装好的函数,这些函数也是Jni编程中经常被使用到的,要想调用这些函数就需要使用JNIEnv这个对象,例如:env->GetObjectClass()。
jobject obj:代表着native方法的调用者,本例即new NativeDemo();但如果native是静态的,那就是NativeDemo类。
2.2 动态注册
- 动态注册不再按照特定的规则去实现native函数,只要在.c文件里面根据对应的规则声明函数即可,所以我们可以不用默认的映射规则,直接由我们告诉JVM,java的native函数对应的是C文件里面的哪个函数。
- 优缺点: 函数名看着舒服一些,但是需要在C代码中维护Java Native函数与C函数的对应关系; 灵活性稍高(如果修改了java native函数所在类的包名或类名,仅调整Java native函数的签名信息)
//Java 层代码JniSdk.java
public class JniSdk {
static {
System.loadLibrary("jnisdk");
}
public static native int numAdd(int a, int b);
public native void dumpMessage();
}
//Native层代码 jnidemo.cpp
JNINativeMethod g_methods[] = {
{"numAdd", "(II)I", (void*)add},
{"dumpMessage","()V",(void*)dump},
};
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
j_vm = vm;
JNIEnv *env = NULL;
if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK) {
return -1;
}
jclass clazz = env->FindClass("com/dong/example/JnidemoClass");
//第一个参数clazz:是对应的类名的完整路径,(把.换成/)
//第一个参数g_methods:是定义的全局变量
//第一个参数2:是g_methods的数组长度,也可以用sizeof(g_methods)/sizeof(g_methods[0])
jint ret = env->RegisterNatives(clazz, g_methods, 2);
if (ret != 0) {
LOGI("register native methods failed");
}
return JNI_VERSION_1_6;
}
上面的JNI_OnLoad函数是在我们通过System.loadlibrary函数的时候,JVM会回调的一个函数,我们就是在这里做的动态注册的事情,通过env->RegisterNatives注册。
2.3 这里主要讲解一下g_methods对象,下面是JNINativeMethods结构体的定义
typedef struct {
const char* name; //对应java中native的函数名
const char* signature; //java中native函数的函数签名
void* fnPtr; //C这边实现的函数指针
} JNINativeMethod;
三、函数签名
3.1 什么是函数签名:
所谓函数签名,简单点的理解可以理解成一个函数的唯一标识,一个签名对应着一个函数的签名。这个是一一对应的关系。有些人可能会问:函数名不能作为标识么?答案当然是否定的
3.2 为什么需要函数的签名:
我们知道,java是支持函数重载的。一个类里面可以有多个同名但是不同参数的函数,所以函数名+参数名才唯一构成一个函数标识,因此我们需要针对参数做一个签名标识。这样jni层才能唯一识别到一个函数
3.3 如何获取函数的签名
函数的签名是针对函数的参数以及返回值进行组成的。它遵循如下格式(参数类型1;参数类型2;参数类型3…)返回值类型。例如我们上面的numAdd函数一样。他在java层的函数声明是:
public static native int numAdd(int a, int b);
两个参数都是int,并且返回值也是int,所以的函数签名是(II)I。public native void dumpMessage();
而dumpMessage函数没有任何参数,并且返回值也是空,所以它的签名是()V
3.6 函数类型对应的签名的映射关系:
类型标识 Java类型
Z boolean
B byte
C char
S short
I int
J long
F float
D double
L/java/language/String String
[I int[]
[Ljava/lang/object Object[]
V void
四、JNIEnv
4.1 JNIEnv介绍
JNIEnv贯穿了整个JNI技术的核心,java层调用native函数主要通过映射关系的建立,但jni函数调用java层的函数就要通过JNIEnv了
4.2 何为JNIEnv
JNIEnv是JVM内部维护的一个和线程相关的代表JNI环境的结构体,这个结构体是和线程相关的。并且C函数里面的线程与java函数中的线程是一一对应关系。也就是说,如果在java里的某个线程调用jni接口,不管调用多少个JNI接口,传递的JNIEnv都是同一个对象。因为这个时候java只有一个线程,对应的JNI也只有一个线程,而JNIEnv是跟线程绑定的,因此也只有一个
4.2 通过JNIEnv调用java对象方法,通过JNIEnv调用方法大致可以分为以下两步:
a、获取到对象的class,并且通过class获取成员属性
b、通过成员属性设置获取对应的值或者调用对应的方法
c、注意如果jni方法是通过static方式调用的话,这边的jobject表示的是jclass对象,需要进行强转,并不表示一个独立的对象
public class JniSdk {
private int mIntArg = 5;
public int getArg() {
return mIntArg;
}
}
void dump(JNIEnv *env, jobject obj) {
LOGI("this is dump message call: %p", obj);
jclass jc = env->GetObjectClass(obj);
jmethodID jmethodID1 = env->GetMethodID(jc,"getArg","()I");
jfieldID jfieldID1 = env->GetFieldID(jc,"mIntArg","I");
jint arg1 = env->GetIntField(obj,jfieldID1);
jint arg = env->CallIntMethod(obj, jmethodID1);
LOGI("show int filed: %d, %d",arg, arg1);
}
4.3 跨线程如何调用java方法
- 上面可以直接调用的原因是java调用到jni层的时候始终都在同一个线程,因此再jni层可以直接操作从java层传递下来的JNIEnv对象来实现各种操作。但是如果是在JNI层创建的一个额外的线程想调用Java方法呢?这个时候又该如何操作呢?
- 一个java线程和一个jni线程共同拥有一个JNIEnv,如果java线程调用native函数的时候,JVM还没有为这两个线程建立起映射关系,那么就会新创建一个JNIEnv并且传递到jni线程
- 如果之前已经有创建过映射关系。那么就直接采用原来的JNIEnv 。如上面所描述的那样,两个JNIEnv的对象是相同的
- 反之也一样,如果jni调用java线程的话,那么需要向JVM申请获取到已经映射的JNIEnv,如果之前未映射过的话。那么就重新创建一个,这个方法就是AttachCurrentThread。
JNIEnv *g_env;
void *func1(void* arg) {
//进入另一个新线程
//使用全局保存的g_env,进行操作java对象的时候程序会崩溃
jmethodID jmethodID1 = g_env->GetMethodID(jc,"getArg","()I");
jint arg = g_env->CallIntMethod(obj, jmethodID1);
//通过这种方法获取的env,然后再进行获取方法进行操作不会崩溃
JNIEnv *env;
j_vm->AttachCurrentThread(&env,NULL);
}
void dumpArg(JNIEnv *env, jobject call_obj, jobject arg_obj) {
//打印线程
LOGI("on dump arg function, env :%p", env);
g_env = env;
pthread_t *thread;
pthread_create(thread,NULL, func1, NULL);
}
上面表示JNIEnv跟每个线程是捆绑的,无法在线程B访问到线程A的JNIEnv,所以通过保存g_env的方式去使用是不行的。而是应该要通过AttachCurrentThread方法进行获取新的JNIEnv,然后再进行调用。
五、销毁
- java创建的对象是由垃圾回收器来回收和释放内存的,但java的那种方式在jni那边是行不通的。
- 在JNI层,如果使用ObjectA = ObjectB的方式来保存变量的话,这种是没办法保存变量的,随时会被回收,我们必须要通过env->NewGlobalRef和env->NewLocalRef的方式来创建,还有一个env->NewWeakGlobalRef(这种很少使用)
- 两种的生命周期的情况如下:
- NewLocalRef创建的变量再函数调用结束后会被释放掉
- NewGlobalRef创建的变量除非手动delete掉,否则会一直存在
六、JNIEnv操作Java端的代码,主要方法:
函数名称 | 作用 |
---|---|
NewObject | 创建Java类中的对象 |
NewString | 创建Java类中的String对象 |
NewArray | 创建类型为Type的数组对象 |
GetField | 获得类型为Type的static的字段 |
SetField | 创建Java类中的对象 |
GetStaticField | 创建Java类中的对象 |
SetStaticField | 设置类型为Type的static的字段 |
CallMethod | 调用返回值类型为Type的static方法 |
CallStaticMethod | 调用返回值类型为Type的static方法 |
七、Java 、C/C++中的常用数据类型的映射关系表
JNI中定义的别名 | Java类型 | C/C++类型 |
---|---|---|
jint / jsize | int | int |
jshort | short | short |
jlong | long | long / long long (__int64) |
jbyte | byte | signed char |
jboolean | boolean | unsigned char |
jchar | char | unsigned short |
jfloat | float | float |
jdouble | double | double |
jobject | Object | _jobject* |
jbyteArray | byte[] | signed byte[] |
jcharArray | char[] | unsigned char[] |
jdoubleArray | double[] | unsigned double[] |
jfloatArray | float[] | unsigned float[] |
jintArray | int[] | unsigned int[] |
jshortArray | short[] | unsigned short[] |
jlongArray | long[] | unsigned long[] |
jbooleanArray | boolean[] | unsigned bool[] |
八、函数类型对应的签名的映射关系:
Java类型 | 字段描述符(签名) | 备注 |
---|---|---|
int | I | int的首字母、大写 |
float | F | float的首字母、大写 |
double | D | double的首字母、大写 |
short | S | short的首字母、大写 |
long | L | long的首字母、大写 |
char | C | char的首字母、大写 |
byte | B | byte的首字母、大写 |
boolean | Z | 因B已被byte使用,所以JNI规定使用Z |
object | L + /分隔完整类名 | String 如: Ljava/lang/String |
array | [ + 类型描述符 | int[] 如:[I |
void | V | i无返回值类型 |
Method | (参数字段描述符…)返回值字段描述符 | int add(int a,int b) 如:(II)I |
byte[] | [B | 相比普通类型多了“[”来表示数组 |
char[] | [C | 同上… |
double[] | [D | … |
float[] | [F | … |
int[] | [I | … |
short[] | [S | … |
long[] | [J | … |
boolean[] | [Z | … |
九、JNI 打印日志
9.1 Cmake文件中有log模块引用,不然编译不通过
# 编译一个库
add_library(
native-lib # 库的名字
SHARED # 动态库(.so库)
native-lib.cpp # 需要编译的C++文件
)
# 相当于定义一个变量log-lib,引用安卓的打印模块
find_library(
log-lib
log
)
# 将变量log-lib连接到so库(我这边的so库名字是native-lib)中,这样这个库就能使用日志了
target_link_libraries(
native-lib
${log-lib}
)
9.2 然后在cpp文件中加入:
#include <android/log.h>
#define TAG "kang"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__);
9.3 使用日志打印:
extern "C" JNIEXPORT jstring JNICALL
Java_com_example_jnidemo_MainActivity_stringFromJNI(JNIEnv* env,jobject) {
std::string hello = "Hello from C++";
LOGD("jni打印(LOGD)")
LOGE("jni打印(LOGE)")
LOGI("jni打印(LOGI)")
return env->NewStringUTF(hello.c_str());
}
十、完整源码
10.1,静态注册:
Native层:NativeLib.java
package com.bob.nativelib;
public class NativeLib {
static {
System.loadLibrary("nativelib");
}
public native String stringFromJNI();
}
C++层:nativelib.cpp
#include <jni.h>
#include <string>
#include <android/log.h>
#define TAG "kang"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__);
extern "C" JNIEXPORT jstring JNICALL
Java_com_bob_nativelib_NativeLib_stringFromJNI(
JNIEnv* env,
jobject /* this */) {
std::string hello = "Hello from C++";
LOGE("Hello from C++");
return env->NewStringUTF(hello.c_str());
}
java调用层
//静态注册
public static void main(String[] args) {
NativeLib nativeLib=new NativeLib();
System.out.println(nativeLib.stringFromJNI());
}
10.2,动态注册:C语言
native层:JNITools.java
package com.bob.nativelib;
public class JNITools {
static {
System.loadLibrary("dynamicnativelib");
}
public static native int add(int a,int b);
}
C层:dynamicnativelib.c
#include "jni.h"
//日志打印
#include <android/log.h>
#define TAG "kang"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__);
//加
jint addNumber(JNIEnv *env,jclass clazz,jint a,jint b){
return a+b;
}
//三个参数,java层函数名,java 层方法签名,C 层方法指针
//获取签名方法: javap -s -p DynamicRegister.class
static const JNINativeMethod methods[]={
{"add","(II)I",(void*)addNumber},
};
//java层load时,便会自动调用该方法
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void *reserved){
JNIEnv* env = NULL;
//获得 JniEnv
int r = (*vm)->GetEnv(vm,(void**)&env,JNI_VERSION_1_6);
if(r != JNI_OK){
return -1;
}
//FindClass,反射,通过类的名字反射
jclass mainActivityCls = (*env)->FindClass(env, "com/bob/nativelib/JNITools");//注册 如果小于0则注册失败
//注册方法
r = (*env)->RegisterNatives(env,mainActivityCls,methods,sizeof(methods)/sizeof(methods[0]));
if(r != JNI_OK){
return -1;
}
return JNI_VERSION_1_6;
}
java调用层:
//动态注册
public static void main(String[] args) {
//动态注册c库
JNITools jniTools=new JNITools();
System.out.println(String.valueOf(jniTools.add(100,100)));
}
10.3,动态注册:C++语言
native层:JNITools2.java
package com.bob.nativelib;
public class JNITools2 {
static {
System.loadLibrary("dynamicnativelib2");
}
public static native int add(int a,int b);
}
C++层:dynamicnativelib2.cpp
#include <jni.h>
//加
jint addNumber(JNIEnv *env,jclass clazz,jint a,jint b){
return a+b;
}
//三个参数,java层函数名,java 层方法签名,C 层方法指针
//获取签名方法: javap -s -p DynamicRegister.class
static const JNINativeMethod methods[]={
{"add","(II)I",(void*)addNumber},
};
//java层load时,便会自动调用该方法
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved){
//获得 JniEnv
JNIEnv *jniEnv{nullptr};
if (vm->GetEnv((void **) &jniEnv, JNI_VERSION_1_6) != JNI_OK) {
return -1;
}
//FindClass,反射,通过类的名字反射
jclass mainActivityCls = jniEnv->FindClass("com/bob/nativelib/JNITools2");//注册 如果小于0则注册失败
//注册方法
jint ret=jniEnv->RegisterNatives(mainActivityCls,methods,sizeof(methods)/sizeof(methods[0]));
if (ret != 0) {
return -1;
}
return JNI_VERSION_1_6;
}
java调用层:
//动态注册
public static void main(String[] args) {
//动态注册c++库
JNITools2 jniTools2=new JNITools2();
System.out.println(String.valueOf(jniTools2.add(100,100)));
}
10.4 jin调用java层
native层:TestCallBack.java
package com.bob.nativelib;
public class TestCallBack {
static {
System.loadLibrary("jnitojava");
}
//回调方法 里面调用了add
public native void callBackAdd();
public int add(int x,int y){
return x+y;
}
}
C++层:jnitojava.cpp
#include <jni.h>
#include <string>
#include <android/log.h>
#define TAG "kang"
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);
extern "C" JNIEXPORT void JNICALL
Java_com_bob_nativelib_TestCallBack_callBackAdd(JNIEnv* env,jobject) {
//1得到字节码 包名:com.bob.nativelib
jclass jclazz = env->FindClass("com/bob/nativelib/TestCallBack");
//2得到方法
jmethodID jmethodIds = env->GetMethodID(jclazz,"add","(II)I");
//3实例化
jobject object = env->AllocObject(jclazz);
//4调用方法
jint result= env->CallIntMethod(object,jmethodIds,100,1);
//5打印结果
LOGE("result:%d",result);
}
java调用层:
public static void main(String[] args) {
TestCallBack testCallBack=new TestCallBack();
testCallBack.callBackAdd();
System.out.println(String.valueOf(testCallBack.add(600,600)));
}
10.5,完整的CMakeLists.txt
原来的JNI项目是需要自己手动配置的,有了CMake就简单多了,会自动帮我们配置项目,第11节将讲述CMake的优势
# For more information about using CMake with Android Studio, read the
# documentation: https://d.android.com/studio/projects/add-native-code.html
# Sets the minimum version of CMake required to build the native library.
cmake_minimum_required(VERSION 3.10.2)
# Declares and names the project.
project("nativelib")
# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds them for you.
# Gradle automatically packages shared libraries with your APK.
# 编译一个库
add_library( # Sets the name of the library.
nativelib
# Sets the library as a shared library.
SHARED
# Provides a relative path to your source file(s).
nativelib.cpp)
add_library(
# 库的名字
dynamicnativelib
# 动态库(.so库)
SHARED
# 需要编译的C++文件
dynamicnativelib.c)
add_library(
# 库的名字
dynamicnativelib2
# 动态库(.so库)
SHARED
# 需要编译的C++文件
dynamicnativelib2.cpp)
add_library(
# 库的名字
jnitojava
# 动态库(.so库)
SHARED
# 需要编译的C++文件
jnitojava.cpp)
# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.
find_library( # Sets the name of the path variable.
log-lib
# Specifies the name of the NDK library that
# you want CMake to locate.
log )
# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.
# 将变量log-lib连接到so库(我这边的so库名字是native-lib)中,这样这个库就能使用日志打印功能了
target_link_libraries( # Specifies the target library.
nativelib
# Links the target library to the log library
# included in the NDK.
${log-lib} )
target_link_libraries( # Specifies the target library.
dynamicnativelib
# Links the target library to the log library
# included in the NDK.
${log-lib} )
target_link_libraries( # Specifies the target library.
dynamicnativelib2
# Links the target library to the log library
# included in the NDK.
${log-lib} )
target_link_libraries( # Specifies the target library.
jnitojava
# Links the target library to the log library
# included in the NDK.
${log-lib} )
10.5:总结
c库和c++库还是有些区别的,下面要注意的几点,不然编译不通过
a,头部引用
C语言 #include "jni.h"
C++ #include <jni.h>
b,JNIEnv指针引用和FindClass函数参数有区别
//C语言,FindClass,反射,通过类的名字反射
jclass mainActivityCls = (*env)->FindClass(env, "com/bob/nativelib/JNITools");
//C++语言,FindClass,反射,通过类的名字反射
jclass mainActivityCls = env->FindClass("com/bob/nativelib/JNITools2");
十一,CMake
10.1 CMake的优势:
- 可以直接的在C/C++代码中加入断点,进行调试
- java引用的C/C++中的方法,可以直接ctrl+左键进入
- 对于include的头文件或者库,也可以直接进入
- 不需要配置命令行操作,手动的生成头文件,不需要配置android.useDeprecatedNdk=true属性
10.2 传统JNI方式步骤:
- 新建jni目录,写好C/C++代码,注册JNI时我们使用了javah -jni对JAVA类进行操作,自动生成了jni目录以及对应的头文件,然后根据头文件写了C/C++代码。
- 在jni目录下创建且配置好Android.mk和Application.mk两个文件。
- build.gradle文件中根据情况进行配置,可不进行配置使用默认值。
- 通过ndk-build操作,我们能得到对应的so文件,放置在相应位置,java代码中即可调用C/C++代码,运行程序。
10.3 CMake方式步骤:
- 新建cpp目录,写好C/C++代码。
- 创建且配置CMakeLists.txt文件。
- build.gradle文件中根据情况进行配置,CMakeLists.txt文件的路径必须配置。
- java代码中即可调用C/C++代码,运行程序。
- project的build.gradle文件中,gradle版本不能低于2.2,否则会报错。
10.4 CMake和传统JNI的主要区别
- 以前的jni目录改成cpp,名字更换了,下面还是存放C/C++文件。
- 之前对C/C++文件的编译配置Android.mk、Application.mk文件放在jni目录下,现在改成CMakeLists.txt文件。事实上这些文件的位置是可任意存放的,只需要配置好就行。但最好还是按照默认习惯放置。
更多推荐
所有评论(0)