前言
长文预警,本文是JNI开发的基础知识介绍和使用经验总结,基本上涵盖了Android JNI开发的大多数知识点,因此文章较长。
1. NDK介绍
1.1 NDK简介
NDK,即原生开发套件 (Native Development Kit),它是一套工具集,让我们能够在 Android 应用中使用 C/C++代码。Android Studio首先使用NDK 将 C/C++ 代码编译成原生库,然后使用集成构建系统 Gradle 将原生库打包到 APK 中。Java 代码随后可以通过JNI(Java原生接口)框架调用原生库中的C/C++函数。
NDK主要包括了:
- 从C / C++生成原生代码库所需要的工具和构建文件。
- 支持Android平台的一系列原生系统(C/C++、JNI)的头文件和库。
1.2 NDK的使用场景
我们知道,C/C++是比java更底层的语言,C/C++的执行效率更高、延迟更小,因此在某些情况下我们可能会使用NDK,通过Java代码来调用C/C++代码,完成一些工作。例如:
- 进一步提升设备性能,以降低延迟,或运行计算密集型应用,如游戏或物理模拟。
- 重复使用已有的 C 或 C++ 库。
- 图像、音频、视频处理。
1.3 下载 NDK 和工具
要进行NDK开发,我们需要下载以下组件:
- Android 原生开发套件 (NDK):编译C/C++
- CMake:C/C++构建工具,类似Makefile,比Makefile使用更加方便。可与 Gradle 搭配使用来构建原生库。
- LLDB:Android Studio 用于调试原生代码的调试程序。
我们可以直接在SDKManager中下载这三个组件。
NDK.png
2. JNI简介
JNI (Java Native Interface),即java本地接口,它是为java语言和其它语言交互调用而设计的标准应用程序接口。JNI允许JVM中运行的Java代码与用其他编程语言(例如C,C ++和汇编)编写的应用程序和库进行交互操作。
实际使用中,JNI的一个重要的用途是让java通过JNI调用C/C++函数。C/C++函数编译后就存放在库文件中,如大家所知,库文件在Windows平台是DLL文件,在UNIX/Linux平台上是SO文件。而库文件和本地环境是强依赖的,是不具备跨平台特性的。因此,想要实现跨平台,就必须提供在所有的目标平台能运行的库文件。例如实现常见的android平台,一般需要提供这些版本的库文件:arm64-v8a, armeabi, armeabi-v7a, mips, mips64, x86, x86_64。
3. JNI版Hello world
和学习所有编程语言一样,我们首先来写一个JNI版的Hello world。
3.1 手动编译和使用JNI
虽然很繁琐,但是为了完整的了解JNI的开发流程,我们还是要先来说说手动编译和使用JNI的一般流程:
- a. 编写Test.java,添加native方法
package com.qxt;
public class Test {
public static native String sayHello();
}
- b. 使用javac命令将Test.java编译生成Test.class:
javac Test.java
- c. 使用javah命令将Test.class编译生成com_qxt_Test.h头文件。注意要指定正确的classpath。
javah com.qxt.Test
生成的com_qxt_Test.h头文件:
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_qxt_Test */
#ifndef _Included_com_qxt_Test
#define _Included_com_qxt_Test
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: com_qxt_Test
* Method: sayHello
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_com_qxt_Test_sayHello
(JNIEnv *, jclass);
#ifdef __cplusplus
}
#endif
#endif
-
d. 编写com_qxt_Test.cpp实现头文件,并实现具体的函数。
com_qxt_Test.cpp文件:
#include <jni.h>
extern "C" JNIEXPORT jstring JNICALL
Java_com_qxt_Test_sayHello(
JNIEnv* env,
jclass clazz) {
return env->NewStringUTF("Hello world from JNI");
}
- e. 使用Makefile或者Cmake构建和使用NDK编译com_qxt_Test.cpp或者com_qxt_Test.c源文件,生成libtest.so库文件
Application.mk:
APP_ABI := armeabi-v7a arm64-v8a
Android.mk:
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := test
LOCAL_C_INCLUDES := ./
LOCAL_SRC_FILES := ./com_qxt_Test.cpp
LOCAL_LDLIBS := -llog
include $(BUILD_SHARED_LIBRARY)
NDK编译命令:
ndk-build NDK_PROJECT_PATH=. NDK_APPLICATION_MK=Application.mk APP_BUILD_SCRIPT=Android.mk
- f. 在Test.java中使用静态代码块加载库文件:
static {
System.loadLibrary("test");
}
可以看到手动编译和使用JNI的流程是比较麻烦的,不禁让人想起大学时代初学java,老师让大家用记事本手撕java项目的恐惧。不过幸运的是google的Android Studio已经可以帮我们完成这些工作。接下来将介绍使用Android Studio开发JNI。
3.2 使用Android Studio开发JNI
我们只要在Android Studio中选择 File > New Project,在Select a Project Template界面选择Native C++,一路Next往下,一个JNI项目就创建好了,如图:
jni.png
创建好的项目如上图所示。我们无需再生成头文件以及手动写Makefile了,Android Studio已经帮我们完成了这一切,并且新版的Android Studio已经用使用上更加方便的cmake替换了Makefile了。开发时我们只要编辑java文件和cpp文件、配置好CMakeLists.txt、在build.gradle中指定CMakeLists.txt就可以了。在项目编译时,Android Studio会自动编译cpp文件,并将生成的库文件打包到apk或者aab文件当中。我们来看看主要文件的代码:
MainActivity.java:
package com.qxt.test;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class MainActivity extends Activity {
// Used to load the 'native-lib' library on application startup.
static {
System.loadLibrary("native-lib");
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Example of a call to a native method
TextView tv = (TextView) findViewById(R.id.sample_text);
tv.setText(stringFromJNI());
}
/**
* A native method that is implemented by the 'native-lib' native library,
* which is packaged with this application.
*/
public native String stringFromJNI();
}
native-lib.cpp
#include <jni.h>
#include <string>
extern "C" JNIEXPORT jstring JNICALL
Java_com_qxt_myapp_MainActivity_stringFromJNI(
JNIEnv* env,
jobject ) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}
CMakeLists.txt:(为了看起来比较清晰,已删除了无效的注释)
cmake_minimum_required(VERSION 3.4.1)
add_library( native-lib
SHARED
native-lib.cpp )
find_library( log-lib
log )
target_link_libraries( native-lib
${log-lib} )
刚刚我们已经创建了一个简单的JNI项目。
我们注意一下,在native-lib.cpp中本地函数stringFromJNI的参数中有个JNIEnv* env。JNIEnv,顾名思义就是JNI环境变量或者叫JNI接口指针。JNIEnv非常重要,JNI中所有的接口函数都是通过JNIEnv来调用的。
在native-lib.cpp中我们还导入了一个叫jni.h头文件,这个头文件也非常重要。jni.h中定义了JNI的数据类型、数据结构、接口函数、回调函数以及常量等等。在接下来的章节中会逐一介绍相关的重要内容,并举例说明。在最后还会简单介绍cmake的使用。
另外,由于native、method、function等单词翻译的问题,JNI和Java的概念经常容易搞混,因此我们在接下来的章节中,有如下命名约定:
- native方法指代Java层的native方法。
- 本地函数指代JNI层的C/C++函数。
4. JNI的数据类型和数据结构
4.1 基本类型
JNI包括了许多与Java基本类型相对应的基本类型。具体如下表:
JNI和Java基本类型对照表.png
4.2 引用类型
JNI包括了许多与Java引用类型相对应的引用类型。具体如下表:
JNI和Java引用类型对照表.png
4.3 字段和方法ID
除了Java中常用的基本类型和引用类型,JNI还定义了jfieldID和jmethodID。
jfieldID和jmethodID是常规的C指针类型,它们的声明如下:
struct _jfieldID; /* opaque structure */
typedef struct _jfieldID *jfieldID; /* field IDs */
struct _jmethodID; /* opaque structure */
typedef struct _jmethodID *jmethodID; /* method IDs */
在JNI中调用java对象的变量或者方法时常常会用到jfieldID和jmethodID。
4.4 jvalue类型
除了以上介绍的数据类型,JNI还定义了jvalue联合类型,jvalue被用作自变量数组的元素类型。jvalue的声明如下:
typedef union jvalue {
jboolean z;
jbyte b;
jchar c;
jshort s;
jint i;
jlong j;
jfloat f;
jdouble d;
jobject l;
} jvalue;
jvalue在本地函数调用java方法时,经常会被用做参数类型。
4.5 类型签名
JNI同样使用了JVM的类型签名表示。具体如下表:
JVM类型签名对照表.png
例如,对于Java方法:
long f (int n, String s, int[] arr);
它的类型签名为:
(ILjava/lang/String;[I)J
使用javap命令查看类型签名
在接下来的章节中会介绍JNI函数的动态注册,在动态注册时,就需要用到类型签名,而类型签名可以通过javap命令来查看,例如,查看Test.java的类型签名,先将Test.java编译成Test.class。然后:
javap -s Test.class
5. JNI的引用
在了解完JNI的数据类型之后,我们接下来继续说说JNI的引用。JNI的引用分为四种:
- 全局引用(GlobalReferences),全局引用全局有效,JVM无法释放和回收全局引用,全局引用必须通过调用DeleteGlobalRef()显式释放。
分配全局引用:
jobject NewGlobalRef(JNIEnv *env, jobject obj);
释放全局引用:
void DeleteGlobalRef(JNIEnv *env, jobject globalRef);
- 弱全局引用(WeakGlobalReferences),弱全局引用是一种特殊的全局引用,与全局引用不同,JVM可以对它进行垃圾回收。弱全局引用可以在使用全局或局部引用的任何情况下使用。当进行垃圾回收时,如果一个对象仅被弱全局引用所引用,则它将被释放。指向该对象的弱全局引用将指向NULL。因此,使用弱全局引用前需要进行非空判断。我们还可以通过IsSameObject将弱引用与NULL进行比较,来检测弱全局引用是否指向NULL。
分配弱全局引用:
jweak NewWeakGlobalRef(JNIEnv *env, jobject obj);
释放弱全局引用:
void DeleteWeakGlobalRef(JNIEnv *env, jweak obj);
- 局部引用(LocalReferences),局部引用在本地方法调用期间有效,局部引用在本地方法返回后自动释放。每个局部引用都要消耗一定数量的JVM资源。因此,使用时需要确保本地方法不会分配过多的局部引用。尽管在本地方法返回Java之后会自动释放局部引用,但是分配过多的局部引用可能会导致JVM在执行本机方法期间耗尽内存(OOM)。
分配局部引用:
jobject NewLocalRef(JNIEnv *env, jobject ref);
释放局部引用:
void DeleteLocalRef(JNIEnv *env, jobject localRef);
查询局部引用容量:
jint EnsureLocalCapacity(JNIEnv *env, jint capacity);
- 无效引用(InvalidReferences),无效引用一般情况下没有什么用,不展开介绍。
总的来说,JNI的引用并不复杂,但使用时我们仍需要保持良好的编程习惯:
a. 一个引用不管能不能被JVM释放和回收,不再使用后立即显示释放。
b. 在不需要额外引用的情况下,绝不分配新的引用。
6. JNI使用类和对象
6.1 类
DefineClass
/*
* @param env: JNI接口指针.
* @param name: 要定义的类或接口的名称。该字符串以修改后的UTF-8编码。
* @param loader: 分配给已定义类的类加载器。
* @param buf: 包含.class文件数据的缓冲区。
* @param bufLen: 缓冲区长度。
* @return 返回Java类对象,如果发生错误,则返回NULL。
*/
jclass DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize bufLen);
FindClass
/*
* @param env: JNI接口指针。
* @param name: 完全限定的类名(即,包名,以“ /” 分隔,后跟类名,例如java.lang.String:“java/lang/String”)。
* 如果名称以“ [”(数组签名字符)开头,则返回数组类。该字符串以修改后的UTF-8编码。
* @return 返回完全限定的名称的类的对象,如果找不到该类,则返回NULL。
*/
jclass FindClass(JNIEnv *env, const char *name);
GetSuperclass
/*
* @param env: JNI接口指针。
* @param clazz: 一个Java类对象。
* @return 返回以clazz所属类的超类或者NULL。
*/
jclass GetSuperclass(JNIEnv *env, jclass clazz);
IsAssignableFrom
/*
* @param env: JNI接口指针。
* @param clazz1: 第一个类参数。
* @param clazz2: 第二个类参数。
* @return 如果以下任一条件为真,则返回JNI_TRUE:
* 第一个类参数和第二个类参数引用相同的Java类。
* 第一个类参数是第二个类参数的子类。
* 第二个类参数为接口,第一个类参数实现了该接口。
*/
jboolean IsAssignableFrom(JNIEnv *env, jclass clazz1, jclass clazz2);
类的使用实例将在后面的小节中和对象一起介绍。
6.2 对象
AllocObject
/*
* 分配新的Java对象,而无需调用该对象的任何构造函数。返回对该对象的引用。clazz参数不能为任何数组类。
* @param env: JNI接口指针。
* @param clazz: 一个Java类对象。
* @return 返回Java对象,无法构造该对象则返回NULL。
*/
jobject AllocObject(JNIEnv *env, jclass clazz);
NewObject
/*
* 构造一个新的Java对象。methodID指定要调用的构造方法。必须通过GetMethodID()获取构造方法的methodID。
* GetMethodID获取构造方法的methodID时方法名为<init>,返回类型为void(V)。clazz参数不能引用数组类。
* @param env: JNI接口指针。
* @param clazz: 一个Java类对象。
* @param methodID:构造函数的methodID。
* @param ...:构造函数的参数。
* @param args:构造函数的参数数组。
* @param args:构造函数参数的va_list。
* @return 返回Java对象,无法构造该对象则返回NULL。
*/
jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
jobject NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
jobject NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
GetObjectClass
/*
* 获取对象所属的类
* @param env: JNI接口指针。
* @param obj:一个Java对象(必须不是NULL)。
* @return 返回一个Java类对象。
*/
jclass GetObjectClass(JNIEnv *env, jobject obj);
GetObjectRefType
/*
* 获取obj的引用类型 。该参数obj可以是局部引用,全局引用或弱全局引用。
* @param env: JNI接口指针。
* @param obj: 局部引用、全局引用或者弱全局引用。
* @return 返回以下枚举值之一:
* 如果obj不是有效的引用,则返回JNIInvalidRefType = 0。
* 如果obj是局部引用类型,则返回JNILocalRefType = 1。
* 如果obj是全局引用类型,则返回JNIGlobalRefType = 2。
* 如果obj是弱全局引用类型,则返回JNIWeakGlobalRefType = 3。
*/
jobjectRefType GetObjectRefType(JNIEnv* env, jobject obj);
IsInstanceOf
/*
* 判断对象是否是类的实例。
* @param env: JNI接口指针。
* @param obj:一个Java对象
* @return obj可以强制转换为clazz返回JNI_TRUE; 否则返回JNI_FALSE。一个NULL对象可以强制转换为任何类。
*/
jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz);
IsSameObject
/*
* 测试两个引用是否引用相同的Java对象。
* @param env: JNI接口指针。
* @param ref1:一个Java对象。
* @param ref2:一个Java对象。
* @return 如果ref1和ref2引用相同的Java对象,或者两者均为NULL,返回JNI_TRUE; 否则返回JNI_FALSE。
*/
jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2);
6.3 类和对象的应用实例
调用类的构造方法创建一个对象。
MainActivity.java:
public native Object testClass(int value);
native-lib.cpp
extern "C" JNIEXPORT jobject JNICALL Java_com_qxt_myapp_MainActivity_testClass(JNIEnv *env, jobject thiz, jint value) {
jclass clazz = env->FindClass("java/lang/Integer");
if (clazz != nullptr) {
jmethodID integerConstructID = env->GetMethodID(clazz, "<init>", "(I)V");
return env->NewObject(clazz, integerConstructID, value);
}
return NULL;
}
6.4 调用实例字段和方法
6.4.1 调用实例字段
GetFieldID
/*
* 返回类的实例(非静态)字段的字段ID。该字段由其名称和签名指定。
* Get<type>Field和Set<type>Field系列函数使用字段ID检索对象字段。
* GetFieldID() 将使未初始化的类被初始化。GetFieldID()无法用于获取数组的长度,获取数组长度请使用GetArrayLength()代替。
*
* @param env: JNI接口指针。
* @param clazz:一个Java类对象。
* @param name:字段名称,以\0结尾的UTF-8字符串。
* @param sig:字段签名,以\0结尾的UTF-8字符串。
* @return 返回字段ID,如果操作失败返回NULL。
*/
jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
Get<type>Field
NativeType Get<type>Field(JNIEnv *env, jobject obj, jfieldID fieldID);
jobject GetObjectField(JNIEnv*, jobject, jfieldID);
jboolean GetBooleanField(JNIEnv*, jobject, jfieldID);
jbyte GetByteField(JNIEnv*, jobject, jfieldID);
jchar GetCharField(JNIEnv*, jobject, jfieldID);
jshort GetShortField(JNIEnv*, jobject, jfieldID);
jint GetIntField(JNIEnv*, jobject, jfieldID);
jlong GetLongField(JNIEnv*, jobject, jfieldID);
jfloat GetFloatField(JNIEnv*, jobject, jfieldID);
jdouble GetDoubleField(JNIEnv*, jobject, jfieldID);
Set<type>Field
void Set<type>Field(JNIEnv *env, jobject obj, jfieldID fieldID, NativeType value);
void SetObjectField(JNIEnv*, jobject, jfieldID, jobject);
void SetBooleanField(JNIEnv*, jobject, jfieldID, jboolean);
void SetByteField(JNIEnv*, jobject, jfieldID, jbyte);
void SetCharField(JNIEnv*, jobject, jfieldID, jchar);
void SetShortField(JNIEnv*, jobject, jfieldID, jshort);
void SetIntField(JNIEnv*, jobject, jfieldID, jint);
void SetLongField(JNIEnv*, jobject, jfieldID, jlong);
void SetFloatField(JNIEnv*, jobject, jfieldID, jfloat);
void SetDoubleField(JNIEnv*, jobject, jfieldID, jdouble);
6.4.2 调用实例方法
GetMethodID
/*
* 返回类或接口的实例(非静态)方法的方法ID。该方法可以在clazz的超类之一中定义,并由继承clazz。该方法由其名称和签名确定。
* 调用 GetMethodID() 将使未初始化的类被初始化。
* 要获取构造函数的方法ID,请提供 <init>作为方法名称,并提供 void(V)作为返回类型。
*
* @param env: JNI接口指针。
* @param clazz:一个Java类对象。
* @param name:方法名称,以\0结尾的UTF-8字符串。
* @param sig:方法签名,以\0结尾的UTF-8字符串。
* @return 返回方法ID,如果操作失败返回NULL。
*/
jmethodID GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
Call<type>Method
NativeType Call<type>Method(JNIEnv *env, jobject obj, jmethodID methodID, ...);
NativeType Call<type>MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
NativeType Call<type>MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
这三个操作族中的方法用于从本地函数中调用Java实例方法,它们的区别仅仅是传参机制不同。
/*
* 调用实例方法
* GetMethodID获取构造方法的methodID时方法名为<init>,返回类型为void(V)。clazz参数不能引用数组类。
* @param env: JNI接口指针。
* @param jobject: 一个Java对象。
* @param methodID:java函数的methodID, 必须通过调用GetMethodID()来获得。
* @param ...:java函数的参数。
* @param args:java函数的参数数组。
* @param args:java函数参数的va_list。
* @return 返回Java对象,无法构造该对象则返回NULL。
*/
jobject CallObjectMethod(JNIEnv*, jobject, jmethodID, ...);
jobject CallObjectMethodV(JNIEnv*, jobject, jmethodID, va_list);
jobject CallObjectMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jboolean CallBooleanMethod(JNIEnv*, jobject, jmethodID, ...);
jboolean CallBooleanMethodV(JNIEnv*, jobject, jmethodID, va_list);
jboolean CallBooleanMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jbyte CallByteMethod(JNIEnv*, jobject, jmethodID, ...);
jbyte CallByteMethodV(JNIEnv*, jobject, jmethodID, va_list);
jbyte CallByteMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jchar CallCharMethod(JNIEnv*, jobject, jmethodID, ...);
jchar CallCharMethodV(JNIEnv*, jobject, jmethodID, va_list);
jchar CallCharMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jshort CallShortMethod(JNIEnv*, jobject, jmethodID, ...);
jshort CallShortMethodV(JNIEnv*, jobject, jmethodID, va_list);
jshort CallShortMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jint CallIntMethod(JNIEnv*, jobject, jmethodID, ...);
jint CallIntMethodV(JNIEnv*, jobject, jmethodID, va_list);
jint CallIntMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jlong CallLongMethod(JNIEnv*, jobject, jmethodID, ...);
jlong CallLongMethodV(JNIEnv*, jobject, jmethodID, va_list);
jlong CallLongMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jfloat CallFloatMethod(JNIEnv*, jobject, jmethodID, ...);
jfloat CallFloatMethodV(JNIEnv*, jobject, jmethodID, va_list);
jfloat CallFloatMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
jdouble CallDoubleMethod(JNIEnv*, jobject, jmethodID, ...);
jdouble CallDoubleMethodV(JNIEnv*, jobject, jmethodID, va_list);
jdouble CallDoubleMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
void CallVoidMethod(JNIEnv*, jobject, jmethodID, ...);
void CallVoidMethodV(JNIEnv*, jobject, jmethodID, va_list);
void CallVoidMethodA(JNIEnv*, jobject, jmethodID, const jvalue*);
CallNonvirtual<type>Method
NativeType CallNonvirtual<type>Method(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
NativeType CallNonvirtual<type>MethodA(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, const jvalue *args);
NativeType CallNonvirtual<type>MethodV(JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args);
这三个操作族中的方法用于从本地函数中调用Java实例方法,它们的区别仅仅是传参机制不同。
CallNonvirtual<type>Method族方法和Call<type Method族方法的区别在于:
Call<type>Method基于对象的类来调用方法,而CallNonvirtual<type>Method基于由clazz参数指定的类来调用方法,并从中获取方法ID。方法ID必须从对象的真实类或其超类之一获得。
jobject CallNonvirtualObjectMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jobject CallNonvirtualObjectMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jobject CallNonvirtualObjectMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jboolean CallNonvirtualBooleanMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jboolean CallNonvirtualBooleanMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jboolean CallNonvirtualBooleanMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jbyte CallNonvirtualByteMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jbyte CallNonvirtualByteMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jbyte CallNonvirtualByteMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jchar CallNonvirtualCharMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jchar CallNonvirtualCharMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jchar CallNonvirtualCharMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jshort CallNonvirtualShortMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jshort CallNonvirtualShortMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jshort CallNonvirtualShortMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jint CallNonvirtualIntMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jint CallNonvirtualIntMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jint CallNonvirtualIntMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jlong CallNonvirtualLongMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jlong CallNonvirtualLongMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jlong CallNonvirtualLongMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jfloat CallNonvirtualFloatMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jfloat CallNonvirtualFloatMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jfloat CallNonvirtualFloatMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
jdouble CallNonvirtualDoubleMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
jdouble CallNonvirtualDoubleMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
jdouble CallNonvirtualDoubleMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
void CallNonvirtualVoidMethod(JNIEnv*, jobject, jclass, jmethodID, ...);
void CallNonvirtualVoidMethodV(JNIEnv*, jobject, jclass, jmethodID, va_list);
void CallNonvirtualVoidMethodA(JNIEnv*, jobject, jclass, jmethodID, const jvalue*);
6.4.3 对象的字段和方法使用实例
MainActivity.java:
public int age = 20;
public String getAge(String name) {
return "Hello " + name + ", I'm java method getAge";
}
public native void testObject();
native-lib.cpp:
extern "C" JNIEXPORT void JNICALL Java_com_qxt_myapp_MainActivity_testObject(JNIEnv *env, jobject thiz) {
jclass clazz = env->FindClass("com/qxt/myapp/MainActivity");
if (clazz != nullptr) {
//Access object field
jfieldID ageID = env->GetFieldID(clazz, "age", "I");
jint ageInt = (jint) env->GetIntField(thiz, ageID);
//Access object method
jmethodID getAgeID = env->GetMethodID(clazz, "getAge", "(Ljava/lang/String;)Ljava/lang/String;");
jstring nameStr = env->NewStringUTF("JNI");
jstring msgStr = (jstring) env->CallObjectMethod(thiz, getAgeID, nameStr);
//Use string, convert jstring to char sequence
char *name = (char *) env->GetStringUTFChars(nameStr, NULL);
char *msg = (char *) env->GetStringUTFChars(msgStr, NULL);
LOGD("[testObject] message:%s; age:%d", msg, ageInt);
env->ReleaseStringUTFChars(nameStr, name);
env->ReleaseStringUTFChars(msgStr, msg);
}
env->DeleteLocalRef(clazz);
}
6.5 调用静态的字段和方法
6.5.1 调用静态字段
GetStaticFieldID
/*
* 返回类的静态字段的字段ID。该字段由其名称和签名指定。
* GetStatic<type>Field和SetStatic<type>Field系列函数使用字段ID检索静态字段。
* GetFieldID() 将使未初始化的类被初始化。
*
* @param env: JNI接口指针。
* @param clazz:一个Java类对象。
* @param name:字段名称,以\0结尾的UTF-8字符串。
* @param sig:字段签名,以\0结尾的UTF-8字符串。
* @return 返回字段ID,如果操作失败返回NULL。
*/
jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
GetStatic<type>Field
NativeType GetStatic<type>Field(JNIEnv *env, jclass clazz, jfieldID fieldID);
jobject GetStaticObjectField(JNIEnv*, jclass, jfieldID);
jboolean GetStaticBooleanField(JNIEnv*, jclass, jfieldID);
jbyte GetStaticByteField(JNIEnv*, jclass, jfieldID);
jchar GetStaticCharField(JNIEnv*, jclass, jfieldID);
jshort GetStaticShortField(JNIEnv*, jclass, jfieldID);
jint GetStaticIntField(JNIEnv*, jclass, jfieldID);
jlong GetStaticLongField(JNIEnv*, jclass, jfieldID);
jfloat GetStaticFloatField(JNIEnv*, jclass, jfieldID);
jdouble GetStaticDoubleField(JNIEnv*, jclass, jfieldID);
SetStatic<type>Field
void SetStatic<type>Field(JNIEnv *env, jclass clazz, jfieldID fieldID, NativeType value);
void SetStaticObjectField(JNIEnv*, jclass, jfieldID, jobject);
void SetStaticBooleanField(JNIEnv*, jclass, jfieldID, jboolean);
void SetStaticByteField(JNIEnv*, jclass, jfieldID, jbyte);
void SetStaticCharField(JNIEnv*, jclass, jfieldID, jchar);
void SetStaticShortField(JNIEnv*, jclass, jfieldID, jshort);
void SetStaticIntField(JNIEnv*, jclass, jfieldID, jint);
void SetStaticLongField(JNIEnv*, jclass, jfieldID, jlong);
void SetStaticFloatField(JNIEnv*, jclass, jfieldID, jfloat);
void SetStaticDoubleField(JNIEnv*, jclass, jfieldID, jdouble);
6.5.2 调用静态方法
GetStaticMethodID
/*
* 返回类或接口的静态方法的方法ID。该方法由其名称和签名确定。
* 调用 GetStaticMethodID() 将使未初始化的类被初始化。
* 要获取构造函数的方法ID,请提供 <init>作为方法名称,并提供 void(V)作为返回类型。
*
* @param env: JNI接口指针。
* @param clazz:一个Java类对象。
* @param name:方法名称,以\0结尾的UTF-8字符串。
* @param sig:方法签名,以\0结尾的UTF-8字符串。
* @return 返回方法ID,如果操作失败返回NULL。
*/
jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
CallStatic<type>Method
NativeType CallStatic<type>Method(JNIEnv *env, jclass clazz, jmethodID methodID, ...);
NativeType CallStatic<type>MethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
NativeType CallStatic<type>MethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
jobject CallStaticObjectMethod(JNIEnv*, jclass, jmethodID, ...);
jobject CallStaticObjectMethodV(JNIEnv*, jclass, jmethodID, va_list);
jobject CallStaticObjectMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jboolean CallStaticBooleanMethod(JNIEnv*, jclass, jmethodID, ...);
jboolean CallStaticBooleanMethodV(JNIEnv*, jclass, jmethodID, va_list);
jboolean CallStaticBooleanMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jbyte CallStaticByteMethod(JNIEnv*, jclass, jmethodID, ...);
jbyte CallStaticByteMethodV(JNIEnv*, jclass, jmethodID, va_list);
jbyte CallStaticByteMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jchar CallStaticCharMethod(JNIEnv*, jclass, jmethodID, ...);
jchar CallStaticCharMethodV(JNIEnv*, jclass, jmethodID, va_list);
jchar CallStaticCharMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jshort CallStaticShortMethod(JNIEnv*, jclass, jmethodID, ...);
jshort CallStaticShortMethodV(JNIEnv*, jclass, jmethodID, va_list);
jshort CallStaticShortMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jint CallStaticIntMethod(JNIEnv*, jclass, jmethodID, ...);
jint CallStaticIntMethodV(JNIEnv*, jclass, jmethodID, va_list);
jint CallStaticIntMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jlong CallStaticLongMethod(JNIEnv*, jclass, jmethodID, ...);
jlong CallStaticLongMethodV(JNIEnv*, jclass, jmethodID, va_list);
jlong CallStaticLongMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jfloat CallStaticFloatMethod(JNIEnv*, jclass, jmethodID, ...);
jfloat CallStaticFloatMethodV(JNIEnv*, jclass, jmethodID, va_list);
jfloat CallStaticFloatMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
jdouble CallStaticDoubleMethod(JNIEnv*, jclass, jmethodID, ...);
jdouble CallStaticDoubleMethodV(JNIEnv*, jclass, jmethodID, va_list);
jdouble CallStaticDoubleMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
void CallStaticVoidMethod(JNIEnv*, jclass, jmethodID, ...);
void CallStaticVoidMethodV(JNIEnv*, jclass, jmethodID, va_list);
void CallStaticVoidMethodA(JNIEnv*, jclass, jmethodID, const jvalue*);
6.5.3 静态的字段和方法使用实例
MainActivity.java:
public static String LOG_TAG = "MainActivity";
public static String getLogTag(String name) {
return "Hello " + name + ", I'm java static method getLogTag";
}
public native void testStatic();
native-lib.cpp:
extern "C" JNIEXPORT void JNICALL Java_com_qxt_myapp_MainActivity_testStatic(JNIEnv *env, jobject thiz) {
jclass clazz = env->FindClass("com/qxt/myapp/MainActivity");
if (clazz != nullptr) {
//Access static field
jfieldID logTagID = env->GetStaticFieldID(clazz, "LOG_TAG", "Ljava/lang/String;");
jstring logTagStr = (jstring) env->GetStaticObjectField(clazz, logTagID);
//Access static method
jmethodID getLogTagID = env->GetStaticMethodID(clazz, "getLogTag", "(Ljava/lang/String;)Ljava/lang/String;");
jstring nameStr = env->NewStringUTF("JNI");
jstring msgStr = (jstring) env->CallStaticObjectMethod(clazz, getLogTagID, nameStr);
//Use string, convert jstring to char sequence
char *logTag = (char *) env->GetStringUTFChars(logTagStr, NULL);
char *name = (char *) env->GetStringUTFChars(nameStr, NULL);
char *msg = (char *) env->GetStringUTFChars(msgStr, NULL);
LOGD("[testStatic] message:%s; logTag:%s", msg, logTag);
env->ReleaseStringUTFChars(logTagStr, logTag);
env->ReleaseStringUTFChars(nameStr, name);
env->ReleaseStringUTFChars(msgStr, msg);
}
env->DeleteLocalRef(clazz);
}
7. JNI的字符串
7.1 API介绍
NewString
/*
* 创建unicode字符串
*/
jstring NewString(JNIEnv *env, const jchar *unicodeChars, jsize len);
GetStringLength
/*
* 获取字符串长度
*/
jsize GetStringLength(JNIEnv *env, jstring string);
GetStringChars
/*
* 将字符串转换成字符数组
*/
const jchar * GetStringChars(JNIEnv *env, jstring string, jboolean *isCopy);
ReleaseStringChars
/*
* 释放字符串
*/
void ReleaseStringChars(JNIEnv *env, jstring string, const jchar *chars);
GetStringChars和ReleaseStringChars通常成对使用。
GetStringRegion
/*
* 从字符串中的指定位置复制指定长度的字符到字符数组中
*/
void GetStringRegion(JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
NewStringUTF
/*
* 创建UTF-8字符串
*/
jstring NewStringUTF(JNIEnv *env, const char *bytes);
GetStringUTFLength
/*
* 获取UTF-8字符串长度
*/
jsize GetStringUTFLength(JNIEnv *env, jstring string);
GetStringUTFChars
/*
* 将UTF-8字符串转换成字符数组
*/
const char * GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy);
ReleaseStringUTFChars
/*
* 释放UTF-8字符串
*/
void ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf);
GetStringUTFChars和ReleaseStringUTFChars通常成对使用。
GetStringUTFRegion
/*
* 从UTF-8字符串中的指定位置复制指定长度的字符到字符数组中
*/
void GetStringUTFRegion(JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
7.2 字符串的使用实例
MainActivity.java:
public native String testString(String s);
native-lib.cpp:
extern "C" JNIEXPORT jstring JNICALL Java_com_qxt_myapp_MainActivity_testString(JNIEnv *env, jobject thiz, jstring s) {
//Get java string
char *msg = (char *) env->GetStringUTFChars(s, NULL);
std::string hello = msg;
hello.append("\n");
hello.append("Hello java");
env->ReleaseStringUTFChars(s, msg);
//New java string
return env->NewStringUTF(hello.c_str());
}
8. JNI的数组
8.1 基本类型数组
New<PrimitiveType>Array
ArrayType New<PrimitiveType>Array(JNIEnv *env, jsize length);
jbooleanArray NewBooleanArray(JNIEnv*, jsize);
jbyteArray NewByteArray(JNIEnv*, jsize);
jcharArray NewCharArray(JNIEnv*, jsize);
jshortArray NewShortArray(JNIEnv*, jsize);
jintArray NewIntArray(JNIEnv*, jsize);
jlongArray NewLongArray(JNIEnv*, jsize);
jfloatArray NewFloatArray(JNIEnv*, jsize);
jdoubleArray NewDoubleArray(JNIEnv*, jsize);
Get<PrimitiveType>ArrayElements
NativeType *Get<PrimitiveType>ArrayElements(JNIEnv *env, ArrayType array, jboolean *isCopy);
jboolean* GetBooleanArrayElements(JNIEnv*, jbooleanArray, jboolean*);
jbyte* GetByteArrayElements(JNIEnv*, jbyteArray, jboolean*);
jchar* GetCharArrayElements(JNIEnv*, jcharArray, jboolean*);
jshort* GetShortArrayElements(JNIEnv*, jshortArray, jboolean*);
jint* GetIntArrayElements(JNIEnv*, jintArray, jboolean*);
jlong* GetLongArrayElements(JNIEnv*, jlongArray, jboolean*);
jfloat* GetFloatArrayElements(JNIEnv*, jfloatArray, jboolean*);
jdouble* GetDoubleArrayElements(JNIEnv*, jdoubleArray, jboolean*);
Release<PrimitiveType>ArrayElements
void Release<PrimitiveType>ArrayElements(JNIEnv *env, ArrayType array, NativeType *elems, jint mode);
void ReleaseBooleanArrayElements(JNIEnv*, jbooleanArray, jboolean*, jint);
void ReleaseByteArrayElements(JNIEnv*, jbyteArray, jbyte*, jint);
void ReleaseCharArrayElements(JNIEnv*, jcharArray, jchar*, jint);
void ReleaseShortArrayElements(JNIEnv*, jshortArray, jshort*, jint);
void ReleaseIntArrayElements(JNIEnv*, jintArray, jint*, jint);
void ReleaseLongArrayElements(JNIEnv*, jlongArray, jlong*, jint);
void ReleaseFloatArrayElements(JNIEnv*, jfloatArray, jfloat*, jint);
void ReleaseDoubleArrayElements(JNIEnv*, jdoubleArray, jdouble*, jint);
Get<PrimitiveType>ArrayRegion
void Get<PrimitiveType>ArrayRegion(JNIEnv *env, ArrayType array, jsize start, jsize len, NativeType *buf);
void GetBooleanArrayRegion(JNIEnv*, jbooleanArray, jsize, jsize, jboolean*);
void GetByteArrayRegion(JNIEnv*, jbyteArray, jsize, jsize, jbyte*);
void GetCharArrayRegion(JNIEnv*, jcharArray, jsize, jsize, jchar*);
void GetShortArrayRegion(JNIEnv*, jshortArray, jsize, jsize, jshort*);
void GetIntArrayRegion(JNIEnv*, jintArray, jsize, jsize, jint*);
void GetLongArrayRegion(JNIEnv*, jlongArray, jsize, jsize, jlong*);
void GetFloatArrayRegion(JNIEnv*, jfloatArray, jsize, jsize, jfloat*);
void GetDoubleArrayRegion(JNIEnv*, jdoubleArray, jsize, jsize, jdouble*);
Set<PrimitiveType>ArrayRegion
void Set<PrimitiveType>ArrayRegion(JNIEnv *env, ArrayType array, jsize start, jsize len, const NativeType *buf);
void SetBooleanArrayRegion(JNIEnv*, jbooleanArray, jsize, jsize, const jboolean*);
void SetByteArrayRegion(JNIEnv*, jbyteArray, jsize, jsize, const jbyte*);
void SetCharArrayRegion(JNIEnv*, jcharArray, jsize, jsize, const jchar*);
void SetShortArrayRegion(JNIEnv*, jshortArray, jsize, jsize, const jshort*);
void SetIntArrayRegion(JNIEnv*, jintArray, jsize, jsize, const jint*);
void SetLongArrayRegion(JNIEnv*, jlongArray, jsize, jsize, const jlong*);
void SetFloatArrayRegion(JNIEnv*, jfloatArray, jsize, jsize, const jfloat*);
void SetDoubleArrayRegion(JNIEnv*, jdoubleArray, jsize, jsize, const jdouble*);
8.2 引用类型数组
NewObjectArray
/*
* 构造一个新的数组,它包含 elementClass 类的对象。数组中所有元素的初值都设置为initialElement。
*
* @param env: JNI接口指针。
* @param length:数组长度。
* @param elementClass:数组元素类。
* @param initialElement:数组元素初值。
* @return 返回Java数组对象,无法构造数组则返回NULL。
*/
jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement);
GetObjectArrayElement
/*
* 返回Object数组的元素。
*
* @param env: JNI接口指针。
* @param array:一个Java数组对象。
* @param index:数组索引。
* @return 返回一个Java对象。
*/
jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index);
SetObjectArrayElement
/*
* 设置Object数组的元素。
*
* @param env: JNI接口指针。
* @param array:一个Java数组对象。
* @param index:数组索引。
* @param value:新值。
*/
void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value);
8.3 获取数组长度
GetArrayLength
/*
* 返回数组中元素的数量。
*
* @param env: JNI接口指针。
* @param array:一个Java数组对象。
* @return 返回数组的长度。
*/
jsize GetArrayLength(JNIEnv *env, jarray array);
8.4 数组的使用实例
MainActivity.java:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Example of a call to a native method
TextView tv = findViewById(R.id.sample_text);
int[] arr1 = {1, 1};
String[] arr2 = {"java value"};
String s = "result:" + Arrays.toString(testArray(arr1, arr2))
+ "\n" + "arr1:" + Arrays.toString(arr1)
+ "\n" + "arr2:" + Arrays.toString(arr2);
tv.setText(s);
}
public native int[] testArray(int[] arr1, String[] arr2);
native-lib.cpp:
extern "C" JNIEXPORT jintArray JNICALL Java_com_qxt_myapp_MainActivity_testArray(JNIEnv *env, jobject thiz, jintArray arr1, jobjectArray arr2) {
//Update primitive type array item
jint* _arr1 = env->GetIntArrayElements(arr1, NULL);
int length1 = env->GetArrayLength(arr1);
for (int i = 0; i < length1; i++) {
_arr1[i] = 2;
}
env->ReleaseIntArrayElements(arr1, _arr1, 0);
//Update object array
jstring _arr2 = (jstring) env->GetObjectArrayElement(arr2, 0);
const char* s = env->GetStringUTFChars(_arr2, NULL);
LOGD("[testArray] old arr2[0]:%s", s);
jstring newArr2 = env->NewStringUTF("JNI value");
env->SetObjectArrayElement(arr2, 0, newArr2);
//create new array
int array[2] = {3, 3};
jintArray dst = env->NewIntArray(2);
env->SetIntArrayRegion(dst, 0, 2, array);
return dst;
}
9. JNI的异常
9.1 API介绍
Throw
/*
* 抛出一个 java.lang.Throwable对象。
*
* @param env: JNI接口指针。
* @param obj:java.lang.Throwable对象。
* @return 成功返回0,否则返回负数。
*/
jint Throw(JNIEnv *env, jthrowable obj);
ThrowNew
/*
* 使用指定的消息从指定的类构造一个异常对象,并抛出该异常。
*
* @param env: JNI接口指针。
* @param clazz:java.lang.Throwable的子类
* @param message:用于构造java.lang.Throwable对象的消息。该字符串以修改后的UTF-8编码。
* @return 成功返回0,否则返回负数。
*/
jint ThrowNew(JNIEnv *env, jclass clazz, const char *message);
ExceptionOccurred
/*
* 确定是否引发异常。在本地代码调用ExceptionClear()或Java代码处理该异常之前,该异常将一直被抛出 。
*
* @param env: JNI接口指针。
* @return 返回当前正在抛出的异常对象,如果当前没有抛出异常则返回NULL。
*/
jthrowable ExceptionOccurred(JNIEnv *env);
ExceptionDescribe
/*
* 将异常和堆栈的回溯打印到系统错误报告通道,例如stderr。这是为调试提供的便利例程。
*
* @param env: JNI接口指针。
*/
void ExceptionDescribe(JNIEnv *env);
ExceptionClear
/*
* 清除当前引发的任何异常。如果当前未引发任何异常,则该工作不生效。
*
* @param env: JNI接口指针。
*/
void ExceptionClear(JNIEnv *env);
FatalError
/*
* 引发致命错误,并且不希望VM恢复。此函数不返回。
*
* @param env: JNI接口指针。
* @param msg:错误消息。该字符串以修改后的UTF-8编码。
*/
void FatalError(JNIEnv *env, const char *msg);
ExceptionCheck
/*
* JNI提供的一种便利功能,可以检查正在抛出的异常,而无需创建对异常对象的本地引用。
*
* @param env: JNI接口指针。
* @return 有正在抛出的异常时返回JNI_TRUE;否则返回JNI_FALSE。
*/
jboolean ExceptionCheck(JNIEnv *env);
9.2 异常使用实例
MainActivity.java:
public native void throwException();
native-lib.cpp:
extern "C" JNIEXPORT void JNICALL Java_com_qxt_myapp_MainActivity_throwException(JNIEnv *env, jobject thiz) {
jclass clazz = env->FindClass("java/lang/UnsupportedOperationException");
if (clazz != nullptr) {
env->ThrowNew(clazz, "Sorry, device is unsupported.");
}
env->DeleteLocalRef(clazz);
}
10. 注册native方法
java 中的native方法和JNI中的本地函数,需要建立起对应关系才能正常调用。建立对应关系的方式有两种:
- 静态注册
- 动态注册
10.1 静态注册
本地函数静态注册的格式为:
extern "C" JNIEXPORT [JNI参数类型] JNICALL Java_[包名][类名][方法名](JNIEnv* env, jobject, [JNI参数类型,参数名])
其中,包名、类名、方法名之间的点用下划线代替,包名、类名、方法名都必须与java文件中声明的native方法完全一致,返回类型和参数类型,根据第三节的Java和JNI的参数对照表,一一对应。从第4节中的代码截图可以看到,用Android Studio刚刚创建的这个项目,Android Studio已经自动为我们选择了自动静态注册的方式。
extern "C" JNIEXPORT jstring JNICALL Java_com_qxt_myapp_MainActivity_stringFromJNI(JNIEnv* env, jobject ) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}
静态注册的缺点:
编写不方便,JNI 方法名字必须遵循固定的规则且名字很长,在包名和类名较长的情况下,会显得非常恶心,对于有代码规范强迫症的人,这一点很难忍受。
程序运行效率不高,首次调用native方法时需要根据方法名在JNI中查找对应的本地函数并建立对应关系,这个过程是比较耗时的。
静态注册的优点:
使用方便,本来按手动流程,静态注册使用起来是很麻烦的,但是现在Android Studio已经完美的帮我们解决了这个问题。现在静态注册使用起来非常方便,静态注册的native方法和本地函数之间可以像普通java方法一样进行跳转查看。
10.2 动态注册
在调用 System.loadLibrary的加载库文件时,JNI会回调一个叫 JNI_OnLoad()的函数,在JNI_OnLoad函数中做一些初始化相关的工作。JNI还提供一个叫RegisterNatives的函数,用于注册native方法。它的定义为:
jint RegisterNatives(JNIEnv *env, jclass clazz, const JNINativeMethod *methods, jint nMethods);
因此,我们可以在JNI_OnLoad()的函数中调用RegisterNatives函数注册native方法。 这样提前建立native方法和本地函数的对应关系,优化掉静态注册首次调用需要查找的耗时。动态注册整体流程如下:
- a. 编写cpp实现JNI_Onload()方法。
- b. 将Java 方法和 C/C++方法通过签名信息一一对应起来,可以使用javap -s xx.class查看签名信息。
- c. 使用类名和对应起来的方法作为参数,调用RegisterNatives函数注册native方法。
这里已经写了一个比较标准的模板,可以直接拷贝使用,需要注册新函数时只需要在nativeMethods数组中填写相应的native方法名、签名信息、本地函数名即可。
jstring stringJNI(JNIEnv *env, jobject) {
std::string hello = "Hello from C++";
return env->NewStringUTF(hello.c_str());
}
static int registerNatives(JNIEnv *env) {
//要注册的java类的路径(完整的包名和类名)
const char *className = "com/qxt/myapp/MainActivity";
/*
* 要注册的函数列表
* 参数:
* 1.java中用native关键字声明的函数名
* 2.函数签名,格式:(参数类型)返回类型, 可以使用javap -s xx.class查看
* 3.C/C++中对应函数的函数名(地址)
* */
const JNINativeMethod nativeMethods[] = {
{"stringFromJNI", "()Ljava/lang/String;", (void *) stringJNI},
};
jclass clazz = nullptr;
clazz = env->FindClass(className);
if (clazz == nullptr) {
return JNI_FALSE;
}
int methodsCount = sizeof(nativeMethods) / sizeof(nativeMethods[0]);
//注册函数 参数:java类名, 要注册的函数数组 ,要注册函数的数量
if (env->RegisterNatives(clazz, nativeMethods, methodsCount) < 0) {
return JNI_FALSE;
}
return JNI_TRUE;
}
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env = nullptr;
if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
return JNI_ERR;
}
assert(env != nullptr);
//registerNatives -> env->RegisterNatives
if (!registerNatives(env)) {
return JNI_ERR;
}
return JNI_VERSION_1_6;
}
动态注册的缺点:
- 使用不方便,与静态注册相对的,动态注册的本地函数目前在Android Studio中是无法进行跳转查看的,使用起来相对不方便。
动态注册的优点:
- 流程更加清晰可控。
- 效率更高,提前建立了对应关系,首次调用无需查找。
11. cmake的简单使用介绍
在介绍cmake的使用之前,我们先来回顾一下使用Makefile构建和编译C/C++源代码,一般情况下我们需要在Android.mk文件中:
- 定义头文件路径。
- 定义依赖的库文件路径。
- 定义源代码路径。
- 定义相关的FLAG,ABI等等。(这里只简单介绍cmake的使用,这项不展开讲,有需要的可以去cmake官网看一下。)
- 定义需要链接的库。
对应到CMakeLists.txt也是一样的套路,以下是一个比较常见的cmake使用的例子,包含导入头文件、库文件、链接库文件等等:
#定义支持的cmake的最小版本
cmake_minimum_required(VERSION 3.4.1)
#导入的库对应的头文件的路径
include_directories(${CMAKE_SOURCE_DIR}/src/main/cpp/include)
#定义导入的库
add_library(#库名称
opencv_java3
#库的类型,可以为SHARED或者STATIC,根据导入的库填写,.so为SHARED, .a为STATIC
SHARED
#声明是导入的
IMPORTED)
#定义导入的库文件的路径
set_target_properties(#库名称
opencv_java3
PROPERTIES
#库路径
IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/src/main/jniLibs/${ANDROID_ABI}/libopencv_java3.so)
#定义要编译的库
add_library( #库名称
native-lib
#库的类型,可以为SHARED或者STATIC,一般为SHARED
SHARED
#C/C++源文件,需要完整的路径和名称,源文件可以有多个,每个以空格隔开
native-lib.cpp )
find_library( log-lib
log )
#链接
target_link_libraries( #编译的库
native-lib
#需要依赖的库,可以有多个,每个以空格隔开
opencv_java3
${log-lib} )
cmake就简单介绍一下,我们只需要知道它是用来替代Makefile用来构建和编译C/C++源文件的,并且了解CMakeLists.txt的一般配置,应付一般的JNI项目开发就完全没有问题了。如果需要了解更多cmake的使用,请看官网教程:https://cmake.org/cmake/help/latest/guide/tutorial/index.html
12. 参考:
https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/jniTOC.html
https://blog.csdn.net/qq_20404903/article/details/80662316
https://www.oschina.net/p/android+ndk?hmsr=aladdin1e1
感谢几位原作者辛勤付出。
欢迎交流、点赞、转载,码字不易,转载请注明出处。
网友评论