一、前言
● NDK
Native Development Kit(NDK)是一系列工具的集合。它提供了一系列的工具,帮助开发者快速开发C/C++的动态库,并能自动将so和Java一起打包成apk。
● JNI
Java Native Interface(JNI)标准是java平台的一部分,JNI是Java语言提供的Java和C/C++相互沟通的机制,Java可以通过JNI调用C/C++代码,C/C++的代码也可以调用java代码。
● JNI与NDK的关系
NDK可以为我们生成了C/C++的动态链接库,JNI是java和C/C++沟通的接口,两者与Android没有半毛钱关系,只因为安卓是java程序语言开发,然后通过JNI又能与C/C++沟通,所以我们可以使用NDK+JNI来实现“Java+C”的开发方式。
● 为什么要NDK开发
NDK开发具有以下优点:
1. 项目需要调用底层的一些C/C++的一些东西(java无法直接访问到操作系统底层(如系统硬件等)),或者已经在C/C++环境下实现了功能代码(大部分现存的开源库都是用C/C++代码编写的。),直接使用即可。NDK开发常用于驱动开发、无线热点共享、数学运算、实时渲染的游戏、音视频处理、文件压缩、人脸识别、图片处理等。
2. 为了效率更加高效些。将要求高性能的应用逻辑使用C/C++开发,从而提高应用程序的执行效率。但是C/C++代码虽然是高效的,在java与C/C++相互调用时却增大了开销;
3. 基于安全性的考虑。防止代码被反编译,为了安全起见,使用C/C++语言来编写重要的部分以增大系统的安全性,最后生成so库(用过第三方库的应该都不陌生)便于给人提供方便。(任何有效的代码混淆对于会smail语法反编译你apk是分分钟的事,即使你加壳也不能幸免高手的攻击)
4. 便于移植。用C/C++写得库可以方便在其他的嵌入式平台上再次使用。
二、安装与配置
1. 配置ndk环境:
File->Settings->Appearance&Behavior->System Setings->Android SDK,选中SDK Tools标签页,选择CMake,LLDB,NDK进行安装如下图:CMake:编译配置工具。
LLDB:调试C代码。
NDK:开发工具包。
下载完成后查看 File->Project Structure,是否配置ndk,如果没有就配置一下:
2. 创建工程
接下来重启IDE,新建一个jni工程:
需要勾选include c++ support,项目就可以进行ndk开发
此处有三个可选项目:
1. C++ Standard
指定编译库的环境,其中Toolchain Default使用的是默认的CMake环境。建议选择C++ 11,表示支持C++ 11库。
2. Exceptions Support
如果选中复选框,则表示当前项目支持C++异常处理,建议勾选。
同理,选中复选框,项目支持RTTI,建议勾选。
3. Runtime Type Information Support
这三个东西都是NDK部分:
1. .externalNativeBuild文件夹:cmake编译好的文件, 显示支持的各种硬件等信息。系统生成。
2. cpp文件夹:存放C/C++代码文件,native-lib.cpp文件是该Demo中自带的,可更改。需要自己编写。 (cpp文件相当于原先的jni文件夹)
3. CMakeLists.txt文件:CMake脚本配置的文件。需要自己配置编写。(相当于原先的Android.mk文件)
Gradle中也有两处不同:
CMakelist.txt的内容如下:
# Sets the minimum version of CMake required to build the native
# library. You should either keep the default value or only pass a
# value of 3.4.0 or lower.
cmake_minimum_required(VERSION 3.4.1)
# 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 it for you.
# Gradle automatically packages shared libraries with your APK.
add_library( # Sets the name of the library.
native-lib
# Sets the library as a shared library.
SHARED
# Provides a relative path to your source file(s).
# Associated headers in the same location as their source
# file are automatically included.
src/main/cpp/native-lib.cpp )
# Searches for a specified prebuilt library and stores the path as a
# variable. Because system libraries are included 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 the
# build script, prebuilt third-party libraries, or system libraries.
target_link_libraries( # Specifies the target library.
native-lib
# Links the target library to the log library
# included in the NDK.
${log-lib} )
含义如下:
-
cmake_minimum_required(VERSION 3.4.1)
CMake最小版本使用的是3.4.1。 -
add_library()
配置so库信息(为当前当前脚本文件添加库)-
native-lib
这个是声明引用so库的名称,在项目中,如果需要使用这个so文件,引用的名称就是这个。值得注意的是,实际上生成的so文件名称是libnative-lib。当Run项目或者build项目是,在Module级别的build文件下的intermediates\transforms\mergeJniLibs\debug\folders\2000\1f\main
下会生成相应的so库文件。 -
SHARED
这个参数表示共享so库文件,也就是在Run项目或者build项目时会在目录intermediates\transforms\mergeJniLibs\debug\folders\2000\1f\main
下生成so库文。此外,so库文件都会在打包到.apk里面,可以通过选择菜单栏的*Build->Analyze Apk...**查看apk中是否存在so库文件,一般它会存放在lib目录下。 -
src/main/cpp/native-lib.cpp
构建so库的源文件。
-
STATIC:静态库,是目标文件的归档文件,在链接其它目标的时候使用。
SHARED:动态库,会被动态链接,在运行时被加载。
MODULE:模块库,是不会被链接到其它目标中的插件,但是可能会在运行时使用dlopen-系列的函数动态链接。
拓展:使用第三方库
在一些情况下,我们没有能力开发so库,当别人抛一个库过来的时候我们直接使用就好了。
首先,我们告诉脚本我们只需要导入so库,不需要构建操作。
add_library( imported-lib
SHARED
IMPORTED )
- IMPORTED:表示只需要导入,不需要构建so库。
接着,我们要设置so库的路径了:
set_target_properties(
imported-lib // so库的名称
PROPERTIES IMPORTED_LOCATION // import so库
libs/libimported-lib.so // so库路径
)
当使用已经存在so库时,不应该配置target_link_libraries()方法,因为只有在build 库文件时才能进行link操作。3. 添加调用
public class MainActivity extends AppCompatActivity {
@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();
// Used to load the 'native-lib' library on application startup.
static {
System.loadLibrary("native-lib");
}
4. 自动添加native方法
public native int add(int x, int y);//java传入int值给C,C返回int值给java
public static native String passString(String str);//传入String值,返回String值
public static native int[] passIntArray(int[] intArray);//传入int数组,返回int数组
public native void passOthers(char m_char, boolean m_boolean, byte m_byte, short m_short, long m_long, float m_float, double m_double);//传入其他基本数据类型,无返回值
在声明接口后,用快捷键可在cpp生成相应的函数,如下:
#include "native-lib.h"
JNIEXPORT jint JNICALL
Java_com_hecc_jnitest_JNIManager_add(JNIEnv *env, jobject instance, jint x, jint y) {
return x + y;//返回x,y的和
}
JNIEXPORT jstring JNICALL
Java_com_hecc_jnitest_JNIManager_passString(JNIEnv *env, jclass type, jstring m_str) {
char *str = (char *) env->GetStringUTFChars(m_str, 0);//将java中的String类型的值转化成C识别的char*类型的值
// 对字符串进行(移位)处理
int length = strlen(str);
for (int i = 0; i < length; ++i) {
*(str + i) += 1;
}
env->ReleaseStringUTFChars(m_str, str);//释放内存
return env->NewStringUTF(str);//返回一个处理后的字符串
}
JNIEXPORT jintArray JNICALL
Java_com_hecc_jnitest_JNIManager_passIntArray(JNIEnv *env, jclass type, jintArray m_intArray) {
jint *intArray = env->GetIntArrayElements(m_intArray, NULL);//获取数组的指针
jsize length = env->GetArrayLength(m_intArray);//获取数组长度
// 对数组进行(元素+10)处理
for (int i = 0; i < length; i++) {
*(intArray + i) += 10;
}
env->ReleaseIntArrayElements(m_intArray, intArray, 0);//释放内存
return m_intArray;//返回一个处理后的数组
}
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_passOthers(JNIEnv *env, jobject instance, jchar m_char,
jboolean m_boolean, jbyte m_byte, jshort m_short,
jlong m_long, jfloat m_float, jdouble m_double) {
LOGI("m_char=%c,m_boolean=%d,m_byte=%d,m_short=%hd,m_long=%ld,m_float=%f,m_double=%lf",
m_char, m_boolean, m_byte, m_short, m_long, m_float, m_double);
LOGE("打印:LOGE");
}
C本地函数命名规则: Java_包名_类名_本地方法名
JNIEXPORT,JNICALL:是系统定义的宏,JNIEXPORT后面写函数的输出类型,JNICALL后面写函数名,实测这两个宏可写可不写。
JNIEnv *env: 是结构体JNINativeInterface的二级指针,重定义了大量的函数指针,这些函数指针在jni开发中很常用。可以理解为JNI的上下文环境,需要通过env调用各种接口。
jobject instance :调用本地函数的Java对象,在此例中就是JNIManager的实例。
头文件定义:
#ifndef JNITEST_NATIVE_LIB_H
#define JNITEST_NATIVE_LIB_H
#include <jni.h>
#include <string>
#include <android/log.h>
#define LOG_TAG "System.out.fromC"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
extern "C" {
JNIEXPORT jint JNICALL
Java_com_hecc_jnitest_JNIManager_add(JNIEnv *env, jobject instance, jint x, jint y);
JNIEXPORT jstring JNICALL
Java_com_hecc_jnitest_JNIManager_passString(JNIEnv *env, jclass type, jstring str_);
JNIEXPORT jintArray JNICALL
Java_com_hecc_jnitest_JNIManager_passIntArray(JNIEnv *env, jclass type, jintArray intArray_);
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_passOthers(JNIEnv *env, jobject instance,
jchar m_char, jboolean m_boolean, jbyte m_byte, jshort m_short, jlong m_long,
jfloat m_float, jdouble m_double);
}
#endif
然后在MainActivity写
测试
JNI的代码,如下:
public class MainActivity extends AppCompatActivity {
JNIManager manager = JNIManager.getInstance();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
testJNI();
}
private void testJNI() {
int sum = manager.add(3, 4);
Log.i("MainActivity", "3+4=" + sum);
String str = JNIManager.passString("abc");
Log.i("MainActivity", "abc from C:" + str);
int[] arr = {1, 2, 3};
int[] newArr = manager.passIntArray(arr);
printArr(arr);//打印原数组
printArr(newArr);//打印JNI处理后的新数组
}
void printArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
Log.i("MainActivity", "元素" + i + "=" + arr[i]);
}
}
}
查看结果正确,调用jni函数成功!值得注意的是,此处我打印了两次数组,发现原数组和新数组的结果一致。是不是很意外,其实不难理解,原数组传给C后(对照代码),获取原数组的指针和长度,然后是对其内存地址进行操作。然后返回值是操作后的原数组(所谓的新数组)。因此,两则结果一致就有理可据了,类似思想在JNI中会大量的用到。
如何在NDK环境中打印LOG?
答:需要调用系统库,在CMakeList.txt中配置相关log库(模板demo已配置好),然后在头文件中定义相关宏,如下:char m_char = 'a';
boolean m_boolean = true;
byte m_byte = 1;
short m_short = 2;
long m_long = 30000000000L;
float m_float = 1.2F;
double m_double = 3.333D;
manager.passOthers(m_char, m_boolean, m_byte, m_short, m_long, m_float, m_double)
5. Java->C++的调用和数据传输
在cpp目录添加C/C++文件时,需要CMakeList.txt中进行配置,如下:
public class JNIBean {
public static int jb_int;//静态变量
public boolean jb_boolean;
public byte jb_byte;
public short jb_short;
public long jb_long;
public float jb_float;
public double jb_double;
public String jb_str;
public int[] jb_intArr;
}
CppBean.h的代码,如下:
#ifndef JNITEST_CPPBEAN_H
#define JNITEST_CPPBEAN_H
#include <string>
using namespace std;
#define MCppBean (CppBean::GetInstance())
typedef signed char Bool;
#define MPTrue 1
#define MPFalse 0
typedef unsigned char Byte;
class CppBean {
public:
int getcpp_int() const;
void setcpp_int(int jb_int);
Bool getcpp_Bool() const;
void setcpp_Bool(Bool jb_boolean);
Byte getcpp_byte() const;
void setcpp_byte(Byte jb_byte);
short getcpp_short() const;
void setcpp_short(short jb_short);
long getcpp_long() const;
void setcpp_long(long jb_long);
float getcpp_float() const;
void setcpp_float(float jb_float);
double getcpp_double() const;
void setcpp_double(double jb_double);
string getcpp_str() const;
void setcpp_str(char *str);
int *getcpp_intArr();
void setcpp_intArr(int *intArr, int length);
public:
static CppBean &GetInstance() {
static CppBean instance;
return instance;
}
virtual ~CppBean();
private:
CppBean();
CppBean(const CppBean &);
CppBean &operator=(const CppBean &);
private:
int cpp_int;
Bool cpp_boolean;
Byte cpp_byte;
short cpp_short;
long cpp_long;
float cpp_float;
double cpp_double;
string cpp_str;
int cpp_intArr[];
};
#endif
CppBean.cpp的代码,如下:
#include "cppbean.h"
CppBean::CppBean() {
}
CppBean::~CppBean() {
}
int CppBean::getcpp_int() const {
return cpp_int;
}
void CppBean::setcpp_int(int jb_int) {
cpp_int = jb_int;
}
Bool CppBean::getcpp_Bool() const {
return cpp_boolean;
}
void CppBean::setcpp_Bool(Bool jb_boolean) {
cpp_boolean = jb_boolean;
}
Byte CppBean::getcpp_byte() const {
return cpp_byte;
}
void CppBean::setcpp_byte(Byte jb_byte) {
cpp_byte = jb_byte;
}
short CppBean::getcpp_short() const {
return cpp_short;
}
void CppBean::setcpp_short(short jb_short) {
cpp_short = jb_short;
}
long CppBean::getcpp_long() const {
return cpp_long;
}
void CppBean::setcpp_long(long jb_long) {
cpp_long = jb_long;
}
float CppBean::getcpp_float() const {
return cpp_float;
}
void CppBean::setcpp_float(float jb_float) {
cpp_float = jb_float;
}
double CppBean::getcpp_double() const {
return cpp_double;
}
void CppBean::setcpp_double(double jb_double) {
cpp_double = jb_double;
}
string CppBean::getcpp_str() const {
return cpp_str;
}
void CppBean::setcpp_str(char *str) {
cpp_str.assign(str);
}
int *CppBean::getcpp_intArr() {
return cpp_intArr;
}
void CppBean::setcpp_intArr(int *intArr, int length) {
memcpy(cpp_intArr, intArr, length * 4);
}
然后我们需要在Java中添加接口:
public native void passData(JNIBean bean);
然后在native-lib.h中声明,并在native-lib.cpp中实现(可自动生成):
extern "C" {
...
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_passData(JNIEnv *env, jobject instance, jobject bean);
}
#include "native-lib.h"
#include "cppbean.h"//包含cppbean.h头文件
...
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_passData(JNIEnv *env, jobject instance, jobject bean) {
jclass cls_bean = env->GetObjectClass(bean);//获取字节码对象
jfieldID ids_int = env->GetStaticFieldID(cls_bean, "jb_int", "I");//获取静态字段ID对象
jint jb_int = env->GetStaticIntField(cls_bean, ids_int);//获取相应静态字段的int值
MCppBean.setcpp_int(jb_int);//将int值赋给CppBean中的映射值
jfieldID id_boolean = env->GetFieldID(cls_bean, "jb_boolean", "Z");//获取非静态字段ID对象
jboolean jb_boolean = env->GetBooleanField(bean, id_boolean);//获取相应非静态字段的boolean值
MCppBean.setcpp_Bool(jb_boolean);//将boolean值赋给CppBean中的映射值
jbyte jb_byte = env->GetByteField(bean, env->GetFieldID(cls_bean, "jb_byte", "B"));
MCppBean.setcpp_byte(jb_byte);
MCppBean.setcpp_short(env->GetShortField(bean, env->GetFieldID(cls_bean, "jb_short", "S")));
MCppBean.setcpp_long(env->GetLongField(bean, env->GetFieldID(cls_bean, "jb_long", "J")));
MCppBean.setcpp_float(env->GetFloatField(bean, env->GetFieldID(cls_bean, "jb_float", "F")));
MCppBean.setcpp_double(env->GetDoubleField(bean, env->GetFieldID(cls_bean, "jb_double", "D")));
LOGI("MCppBean中:int字段值=%d,Bool字段值=%d,Byte字段值=%d,short字段值=%hd,long字段值=%ld,float字段值=%f,double字段值=%lf",
MCppBean.getcpp_int(), MCppBean.getcpp_Bool(), MCppBean.getcpp_byte(),
MCppBean.getcpp_short(), MCppBean.getcpp_long(),
MCppBean.getcpp_float(), MCppBean.getcpp_double());
//字符串
jfieldID ids_str = env->GetFieldID(cls_bean, "jb_str", "Ljava/lang/String;");
jstring jb_str = (jstring) env->GetObjectField(bean, ids_str);
char *str = (char *) env->GetStringUTFChars(jb_str, 0);
MCppBean.setcpp_str(str);
env->ReleaseStringUTFChars(jb_str, str);
LOGI("MCppBean中:string字段值=%s", MCppBean.getcpp_str().c_str());
//数组
jfieldID ids_intArr = env->GetFieldID(cls_bean, "jb_intArr", "[I");
jintArray jb_intArr = (jintArray) env->GetObjectField(bean, ids_intArr);
jint *intArray = env->GetIntArrayElements(jb_intArr, NULL);
jsize length = env->GetArrayLength(jb_intArr);
MCppBean.setcpp_intArr(intArray, length);
env->ReleaseIntArrayElements(jb_intArr, intArray, 0);
for (int i = 0; i < length; i++) {
LOGI("数组元素%d:%d", i, *(MCppBean.getcpp_intArr() + i));
}
}
在NDK中基本数据类型转换的写法是固定的:
1.获取javabean的字节码对象
除了通过env->GetObjectClass(object对象)方法,还可通过env->FindClass(“com/hecc/jnitest/JNIManager”)获取,形参填写javabean的全类名(注意要把.转换成/)。
2.获取字段ID对象
java中字段分为静态和非静态两种,对应的api也有两种:
jfieldID GetStaticFieldID(jclass clazz, const char* name, const char* sig);
jfieldID GetFieldID(jclass clazz, const char* name, const char* sig);
形参1:正是步骤一的字节码对象。形参2:方法名。形参3:字段描述符,简单说每个基本数据类型都有一个固定的标记作识别(参考下表)。
![](https://img-my.csdn.net/uploads/201205/25/1337955986_9472.jpg)
(注:另外数组类型的简写,则用”[“加上如表所示的对应类型的简写形式进行表示就可以了,
比如:[I 表示 int []。[L全类名; 表示类类型数组。另外,引用类型(除基本类型的数组外)的标示最后都有个”;”)
3.获取字段值
获取字段值的api也分静态和非静态(本地类型和java类型查上表):
本地基本数据类型 GetStatic[java类型]Field(jclass clazz, jfieldID fieldID);
本地基本数据类型 Get[java类型]Field(jobject obj, jfieldID fieldID);
形参1:若是静态,为字节码对象;非静态,为实例对象。形参2:正是步骤二的字段ID对象。
对于字符串和数组的获取稍微复杂点,所以单独列出。
字符串:jstring其实是_jobject的子类,所以用GetObjectField()获取jstring,而c/c++并不识别jstring类型,别担心,ndk提供了相关api—-GetStringUTFChars(jstring string, jboolean* isCopy)来转换成char *类型。
数组(int数组为例):jintArray也是_jobject的子类,同时ndk提供了相关api来获取数组首地—- GetIntArrayElements(jintArray array, jboolean* isCopy)和数组个数—-GetArrayLength(jarray array)。
在MainActivity添加如下代码,进行测试:
private void testJNI() {
...
JNIBean bean = new JNIBean();
JNIBean.jb_int = 11;
bean.jb_boolean = false;
bean.jb_byte = 22;
bean.jb_short = 33;
bean.jb_long = 30000000000L;
bean.jb_float = 12.34f;
bean.jb_double = 56.789d;
bean.jb_str = "我是测试代码";
bean.jb_intArr = new int[]{1, 23, 456, 78, 9};
manager.passData(bean);
}
运行,打印结果如图:
如何将内部类,类类型数组的数据传递给本地?
首先,在JNIBean 中添加内部类和类类型数组。
public class JNIBean {
...
public JNIChildBean jb_ChildBean;
public JNIChildBean[] jb_arr_ChildBean;
public class JNIChildBean {
public int jcb_int;
}
}
在native-lib中添加如下代码:
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_passData(JNIEnv *env, jobject instance, jobject bean) {
...
//内部类
jfieldID ids_child = env->GetFieldID(cls_bean, "jb_ChildBean", "Lcom/hecc/jnitest/JNIBean$JNIChildBean;");//内部类用$符号,而不是/符号。
jobject jb_child = env->GetObjectField(bean, ids_child);
jclass cls_child = env->GetObjectClass(jb_child);
jint jcb_int = env->GetIntField(jb_child, env->GetFieldID(cls_child, "jcb_int", "I"));
LOGI("jcb_int=%d", jcb_int);
//类类型数组
jfieldID ids_arr_child = env->GetFieldID(cls_bean, "jb_arr_ChildBean",
"[Lcom/hecc/jnitest/JNIBean$JNIChildBean;");
jobjectArray jb_arr_child = (jobjectArray) env->GetObjectField(bean, ids_arr_child);
jsize size = env->GetArrayLength(jb_arr_child);
for (int i = 0; i < size; ++i) {
jobject jab_child = env->GetObjectArrayElement(jb_arr_child, i);//获取每个数组的元素
jint jacb_int = env->GetIntField(jab_child,
env->GetFieldID(env->GetObjectClass(jab_child), "jcb_int", "I"));
LOGI("jacb_int=%d",jacb_int);
}
}
即可获取内部类的数据。
5. C++->Java的回调流程
以上示例,都是以java–>c/c++的形式,实际需求中可能需要c/c++–>java或则java–>c/c++–>java的形式传递。那么现在就以java–>c/c++–>java,我打算在界面上写个按钮,点击按钮开启一个线程调用本地方法,ndk再调用c++的函数处理逻辑(这里让线程睡了3秒,模拟耗时操作),然后c++通过ndk回调java的函数,并打印日志。事件逻辑可能有点复杂,下面按照先后流程贴代码:
在MainActivity在添加如下代码:
public class MainActivity extends AppCompatActivity {
...
//按钮点击事件
public void test(View v) {
new Thread(new Runnable() {
@Override
public void run() {
manager.test();
}
}).start();
}
}
在JNIManager在添加如下代码:
public class JNIManager {
...
public native void test();
//c++调用java的函数
public void printFromC(int sec) {
Log.i("JNIManager", "hello from c after " + sec + "s");
}
}
我打算先创建c++的类,并在CMakeLists.txt中配置
text.h文件:
#ifndef JNITEST_TEST_H
#define JNITEST_TEST_H
extern void runTest();
#endif
text.cpp文件:
#include "test.h"
#include <unistd.h>
#include "native-lib.h"//包含native-lib.h头文件
void runTest() {
int sec = 3;
::sleep(sec); // 睡3秒
call_printFromC(sec);//需要在native-lib.h中声明
}
配置完成后点击同步按钮。
此时在native-lib.h中声明函数:
...
extern "C" {
...
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_test(JNIEnv *env, jobject instance);
}
extern void call_printFromC(int sec);//回调函数
最后是native-lib.cpp的代码:
#include "native-lib.h"
#include "cppbean.h"
#include "test.h"//包含test.h头文件
static JavaVM *m_JavaVM;//java虚拟机
static jclass m_jcls_JNI;
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *java_vm, void *reserved) {
m_JavaVM = java_vm;
JNIEnv *jni_env = 0;
//获取JavaVM的JNIEnv
if (m_JavaVM->GetEnv((void **) (&jni_env), JNI_VERSION_1_4) != JNI_OK) {
return -1;
}
jclass jcls_JNI = jni_env->FindClass("com/hecc/jnitest/JNIManager");
m_jcls_JNI = (jclass) jni_env->NewGlobalRef((jobject) jcls_JNI);//全局变量,方便调用
return JNI_VERSION_1_4;
}
...
JNIEXPORT void JNICALL
Java_com_hecc_jnitest_JNIManager_test(JNIEnv *env, jobject instance) {
runTest();//调用test.h的方法
}
void call_printFromC(int sec) {
JNIEnv *env;
m_JavaVM->AttachCurrentThread(&env, NULL);//获取当前线程的JNIEnv
jmethodID methodID = env->GetMethodID(m_jcls_JNI, "printFromC", "(I)V");
jobject obj_manager = env->AllocObject(m_jcls_JNI);//获取实例对象
env->CallVoidMethod(obj_manager,methodID,sec);
}
众所周知,ndk环境下调用api离不开JNIEnv指针,但是如何在c/c++函数中获取JNIEnv呢?
答:要获取JNIEnv之前,先了解JavaVM ,它代表java的虚拟机,所有的工作都是从获取虚拟机的接口开始的。在加载动态链接库的时候,JVM会调用JNI_OnLoad(JavaVM* jvm, void* reserved)(如果定义了该函数),第一个参数会传入JavaVM指针。然后,通过JVM的AttachCurrentThread(JNIEnv** p_env, void* thr_args)的函数获取JNIEnv。
获取到JNIEnv后,想要调用其他api就方便了。对于ndk回调java函数的格式也是相当固定的:
1.获取函数ID对象
java中函数分为静态和非静态,对应的api:
jmethodID GetStaticMethodID(jclass clazz, const char* name, const char* sig);
jmethodID GetMethodID(jclass clazz, const char* name, const char* sig);
形参1:字节码对象。形参2:方法名。形参3:函数描述符,具体格式是(形参类型)返回值类型,另外形参可以写任意个数,没有返回值用V(表示void型)表示。
2.执行回调函数
也分静态和非静态:
本地基本数据类型 CallStatic(返回值类型)Method(jclass clazz, jmethodID methodID, …)
本地基本数据类型 Call(返回值类型)Method(jobject obj, jmethodID methodID, …)
形参1:若是静态,为字节码对象;非静态,为实例对象。形参2:正是步骤一的函数ID对象。其他形参:这里填写的就是java函数对应的参数值,可以写任意个,没有就不用写。
回调java函数完成,点击test按钮,运行查看结果(等待3秒):
6. C++->Java 赋值
public class JNIBean {
...
public static int[][] jb_intArr2;
}
来看看具体的实现过程:
...
void call_printFromC(int sec) {
int pInt[2][3] = {{1, 2, 3}, {4, 5, 6}};//模拟数据
JNIEnv *env;
m_JavaVM->AttachCurrentThread(&env, NULL);
processJNIBean(env, pInt);//处理数据
jmethodID methodID = env->GetMethodID(m_jcls_JNI, "printFromC", "(I)V");
jobject newManager = env->AllocObject(m_jcls_JNI);
env->CallVoidMethod(newManager, methodID, sec);
}
void processJNIBean(JNIEnv *env, int pInt[2][3]) {
jclass cls_JB = env->FindClass("com/hecc/jnitest/JNIBean");
jobjectArray _infoArr2 = env->NewObjectArray(2, env->FindClass("[I"), NULL);//创建一个长度为2,元素为int[]的jobjectArray
for (int i = 0; i < 2; ++i) {
jintArray _infoArr = env->NewIntArray(3);//创建长度为3的jintArray 数组
env->SetIntArrayRegion(_infoArr, 0, 3, pInt[i]);//给jintArray赋值
env->SetObjectArrayElement(_infoArr2, i, _infoArr);//给jobjectArray赋值
}
jfieldID id_infoArr2 = env->GetStaticFieldID(cls_JB, "jb_intArr2", "[[I"); //静态二维数组ID对象
env->SetStaticObjectField(cls_JB, id_infoArr2, _infoArr2);//设置java端数组数据
}
千万不要忘了在native-lib.h声明函数:
static void processJNIBean(JNIEnv *env,int pInt[2][3]);
然后打印数组元素:
public class JNIManager {
...
//c++调用java的函数
public void printFromC(int sec) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
Log.i("JNIManager","元素["+i+"]["+j+"]="+JNIBean.jb_intArr2[i][j]);
}
}
}
}
赋值成功,和模拟的数据一样。
7. 把现有工程转为NDK工程
对于普通Android项目,都可以通过鼠标右击选择Link C++ Project with Gradle转为NDK项目,通过选择CMake或者ndk-build使开发NDK采用CMake或者JNI方法,不过此种转化方法必须符合CMake或者JNI的目录结构,也就是说,在上图操作完成之前,必须先在项目中建好符合CMake或者JNI规则的目录,假如CMakeLists.txt文件中有对xx.cpp/xx.c的引用,那么必须在cpp目录下新建好对应的xx.cpp/xx.c,同理,android.mk文件要是引用cpp/c文件,那么就要在jni目录新建好对应得文件。
android studio 2.2之后新建NDK项目只能得到CMake方式,所以要想JNI开发,只能普通项目转。
转载: