JNI是一种本地编程接口。它允许运行在JAVA虚拟机中的JAVA代码和用其他编程语言，诸如C语言、C++、汇编，应用和库之间的交互操作。 不只是Android特有的东西
1. Java调用c++方法
静态加载so
static {
System.loadLibrary("native-lib");
}
c++中和java中对应方法
public static native void native11();
extern "C"
JNIEXPORT jstring JNICALL
Java_com_dds_anyndk_AnyNdk_native11(JNIEnv *env, jclass type, jint a, jstring str_, jfloat f) {
// 获得c字符串
const char *str = env->GetStringUTFChars(str_, JNI_FALSE);
char returnStr[100];
//格式化字符串
sprintf(returnStr, "C++ string:%d,%s,%f", a, str, f);
//释放掉内存
env->ReleaseStringUTFChars(str_, str);
return env->NewStringUTF(returnStr);
}
CmakeLists.txt配置
cmake_minimum_required(VERSION 3.4.1)
add_library(
native-lib
SHARED
native11.cpp)
target_link_libraries(
native-lib
log)
2. JNI数据类型
JNIEXPORT 和 JNICALL，定义在jni.h头文件中。
JNIEXPORT：
在 Windows 中,定义为__declspec(dllexport)。因为Windows编译 dll 动态库规定，如果动态库中的函数要被外部调用，需要在函数声明中添加此标识，表示将该函数导出在外部可以调用。
在 Linux/Unix/Mac os/Android 这种 Like Unix系统中，定义为__attribute__ ((visibility ("default")))
JNICALL:
在类Unix中无定义，在Windows中定义为：_stdcall ，一种函数调用约定
类Unix系统中这两个宏可以省略不加。
| Java类型 | 本地类型 | 描述 |
|---|---|---|
| boolean | jboolean | C/C++8位整型 |
| byte | jbyte | C/C++带符号的8位整型 |
| char | jchar | C/C++无符号的16位整型 |
| short | jshort | C/C++带符号的16位整型 |
| int | jint | C/C++带符号的32位整型 |
| long | jlong | C/C++带符号的64位整型 |
| float | jfloat | C/C++32位浮点型 |
| double | jdouble | C/C++64位浮点型 |
| Object | jobject | 任何Java对象，或者没有对应java类型的对象 |
| Class | jclass | Class对象 |
| String | jstring | 字符串对象 |
| Object[] | jobjectArray | 任何对象的数组 |
| boolean[] | jbooleanArray | 布尔型数组 |
| byte[] | jbyteArray | 比特型数组 |
| char[] | jcharArray | 字符型数组 |
| short[] | jshortArray | 短整型数组 |
| int[] | jintArray | 整型数组 |
| long[] | jlongArray | 长整型数组 |
| float[] | jfloatArray | 浮点型数组 |
| double[] | jdoubleArray | 双浮点型数组 |
获取数组类型的数据
extern "C"
JNIEXPORT jstring JNICALL
Java_com_dds_anyndk_AnyNdk_native11_12(JNIEnv *env, jclass type, jobjectArray strs,
jintArray ints_) {
//1、 获得字符串数组
int32_t str_length = env->GetArrayLength(strs);
LOGD("字符串 数组长度:%d", str_length);
for (int i = 0; i < str_length; ++i) {
jstring str = jstring(env->GetObjectArrayElement(strs, i));
const char *c_str = env->GetStringUTFChars(str, JNI_FALSE);
LOGD("字符串有:%s", c_str);
//使用完释放
env->ReleaseStringUTFChars(str, c_str);
}
//2、获得基本数据类型数组
int32_t int_length = env->GetArrayLength(ints_);
LOGD("int 数组长度:%d", int_length);
jint *ints = env->GetIntArrayElements(ints_, nullptr);
for (int i = 0; i < int_length; i++) {
LOGD("int 数据有:%d", ints[i]);
}
env->ReleaseIntArrayElements(ints_, ints, 0);
return env->NewStringUTF("hello");
}
3. C/C++反射Java
在C/C++中反射创建Java的对象，调用Java的方法
基本数据类型的签名采用一系列大写字母来表示, 如下表所示:
| Java类型 | 签名 |
|---|---|
| boolean | Z |
| short | S |
| float | F |
| byte | B |
| int | I |
| double | D |
| char | C |
| long | J |
| void | V |
| 引用类型 | L + 全限定名 + ; |
| 数组 | [+类型签名 |
需要反射的方法
public class JavaHelper {
private static final String TAG = "dds_native11";
//private和public 对jni开发来说没任何区别 都能反射调用
public void instanceMethod(String a, int b, boolean c) {
Log.e(TAG, "instanceMethod a=" + a + " b=" + b + " c=" + c);
}
public static void staticMethod(String a, int b, boolean c) {
Log.e(TAG, "staticMethod a=" + a + " b=" + b + " c=" + c);
}
}
反射调用方法
extern "C"
JNIEXPORT jstring JNICALL
Java_com_dds_anyndk_AnyNdk_native11_13(JNIEnv *env, jclass type) {
jclass class_helper = env->FindClass("com/dds/anyndk/JavaHelper");
// 反射调用静态方法
jmethodID method_staticMethod = env->GetStaticMethodID(class_helper, "staticMethod",
"(Ljava/lang/String;IZ)V");
jstring staticStr = env->NewStringUTF("C++调用静态方法");
env->CallStaticVoidMethod(class_helper, method_staticMethod, staticStr, 1, true);
// 反射调用构造方法
jmethodID constructMethod = env->GetMethodID(class_helper,"<init>","()V");
jobject helper = env->NewObject(class_helper,constructMethod);
jmethodID instanceMethod = env->GetMethodID(class_helper,"instanceMethod","(Ljava/lang/String;IZ)V");
jstring instanceStr= env->NewStringUTF("C++调用实例方法");
env->CallVoidMethod(helper,instanceMethod,instanceStr,2,0);
// 释放资源
env->DeleteLocalRef(class_helper);
env->DeleteLocalRef(staticStr);
env->DeleteLocalRef(instanceStr);
env->DeleteLocalRef(helper);
return env->NewStringUTF("dds");
}
可以使用javap来获取反射方法时的签名
javap -s com.dds.anyndk.JavaHelper
反射修改变量
需要反射的方法
public class JavaHelper {
int a = 10;
static String b = "java字符串";
public void testReflect(JavaHelper javaHelper) {
Log.e(TAG, "修改前 ： a = " + a + " b=" + b);
AnyNdk.native11_4(javaHelper);
Log.e(TAG, "修改后 ： a = " + a + " b=" + b);
}
}
反射
#define LOG_TAG "dds_native4"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__ )
extern "C"
JNIEXPORT void JNICALL
Java_com_dds_anyndk_AnyNdk_native11_14(JNIEnv *env, jclass type, jobject javaHelper) {
jclass clazz = env->GetObjectClass(javaHelper);
//获得int a的标示
jfieldID a = env->GetFieldID(clazz, "a", "I");
// 获取a的值
int value = env->GetIntField(javaHelper, a);
LOGD("获得java属性a:%d", value);
env->SetIntField(javaHelper, a, 100);
// 获取String b 的标示
jfieldID b = env->GetStaticFieldID(clazz, "b", "Ljava.lang.String;");
// 获取静态变量的值
auto bStr = jstring(env->GetStaticObjectField(clazz, b));
const char *bc_str = env->GetStringUTFChars(bStr, JNI_FALSE);
LOGD("获得java属性b:%s", bc_str);
jstring new_str = env->NewStringUTF("C++字符串");
env->SetStaticObjectField(clazz, b, new_str);
// 释放资源
env->ReleaseStringUTFChars(bStr, bc_str);
env->DeleteLocalRef(new_str);
env->DeleteLocalRef(clazz);
}
4. JNI_OnLoad
调用System.loadLibrary()函数时， 内部就会去查找so中的 JNI_OnLoad 函数，如果存在此函数则调用。
JNI_OnLoad会：
告诉 VM 此 native 组件使用的 JNI 版本。
对应了Java版本，android中只支持JNI_VERSION_1_2 、JNI_VERSION_1_4、JNI_VERSION_1_6
在JDK1.8有 JNI_VERSION_1_8。
jint JNI_OnLoad(JavaVM* vm, void* reserved){
// 2、4、6都可以
return JNI_VERSION_1_4;
}
动态注册
在此之前我们一直在jni中使用的 Java_PACKAGENAME_CLASSNAME_METHODNAME 来进行与java方法的匹配，这种方式我们称之为静态注册。
而动态注册则意味着方法名可以不用这么长了，在android aosp源码中就大量的使用了动态注册的形式
//Java：
native void dynamicNative();
native String dynamicNative(int i);
//C++：
void dynamicNative1(JNIEnv *env, jobject jobj){
LOGE("dynamicNative1 动态注册");
}
jstring dynamicNative2(JNIEnv *env, jobject jobj,jint i){
return env->NewStringUTF("我是动态注册的dynamicNative2方法");
}
//需要动态注册的方法数组
static const JNINativeMethod mMethods[] = {
{"dynamicNative","()V", (void *)dynamicNative1},
{"dynamicNative", "(I)Ljava/lang/String;", (jstring *)dynamicNative2}
};
//需要动态注册native方法的类名
static const char* mClassName = "com/dds/anyndk/AnyNdk";
jint JNI_OnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env = NULL;
//获得 JniEnv
int r = vm->GetEnv((void **) &env, JNI_VERSION_1_4);
if (r != JNI_OK) {
return -1;
}
jclass activityCls = env->FindClass(mClassName);
// 注册 如果小于0则注册失败
r = env->RegisterNatives(activityCls, mMethods, 2);
if (r != JNI_OK) {
return -1;
}
return JNI_VERSION_1_4;
}
5. c++线程中调用Java
native调用java需要使用JNIEnv这个结构体，而JNIEnv是由Jvm传入与线程相关的变量。
但是可以通过JavaVM的AttachCurrentThread方法来获取到当前线程中的JNIEnv指针。
JavaVM* _vm = 0;
jobject _instance = 0;
jint JNI_OnLoad(JavaVM* vm, void* reserved){
_vm = vm;
return JNI_VERSION_1_4;
}
void *task(void *args) {
JNIEnv *env;
_vm->AttachCurrentThread(&env, 0);
jclass clazz = env->GetObjectClass(_instance);
jmethodID methodId = env->GetStaticMethodID(clazz, "staticMethod", "(Ljava/lang/String;IZ)V");
jstring staticStr = env->NewStringUTF("C++调用静态方法");
env->CallStaticVoidMethod(clazz, methodId, staticStr, 1, true);
env->DeleteLocalRef(clazz);
env->DeleteLocalRef(staticStr);
_vm->DetachCurrentThread();
return 0;
}
extern "C"
JNIEXPORT void JNICALL
Java_com_dds_anyndk_AnyNdk_native11_15(JNIEnv *env, jclass type, jobject javaHelper) {
pthread_t pid;
_instance = env->NewGlobalRef(javaHelper);
// 开启线程
pthread_create(&pid, 0, task, 0);
}
网友评论