7 FFmpeg4Android：jni中c/c++调用java
7.1 c/c++访问java属性
先来看一个函数定义：
JNIEXPORT jstring JNICALL Java_com_test_jni_TestNative_stringFromJNI
(JNIEnv * env, jobject jobj) {
return (*env)->NewStringUTF(env, "jni development.");
}
参数说明：
1）env：是一个结构体指针的指针，主要用来在C/C++中使用虚拟机的功能，比如说：访问Java方法、属性、创建Java对象、处理字符串等等。
2）jobj：是代表对象或类的结构体
如果native方法不是静态方法，jobj代表该方法所属的java对象
如果native方法是静态方法，jobj代表该方法所属Java类的class对象 //TestNative.class
c与java数据类型对应关系
Java基本数据类型与JNI数据类型的映射关系（在C/C++中用特定的类型来表示Java的数据类型），在反射访问java中属性时需要指定属性的签名，三者的对应关系如下：
| java类型 | c/c++类型 | 签名 |
|---|---|---|
| boolean | jboolean | Z |
| byte | jbyte | B |
| char | jchar | C |
| short | jshort | S |
| int | jint | I |
| long | jlong | L |
| float | jfloat | F |
| double | jdouble | D |
| void | void | V |
引用类型（对象）
| java类型 | c/c++类型 | 签名 |
|---|---|---|
| String | jstring | Ljava/lang/String; |
| Object | jobject | Ljava/lang/Object; |
| byte[] | jByteArray | [B |
| Class | jclass |
对象类型以L开头，然后/分隔包的完整类型，后面再加";"。
数组类型以[开头，在加上数据元素类型的签名，如int[]，签名就是[I；再比如int[][]，签名就是[[I，object数组签名就是[Ljva/lang/Object;。
7.1.1 访问一般属性
如有java类JniTest：
package com.lzp.jni;
import java.util.Random;
import java.util.UUID;
public class JniTest {
public String key = "walker";
public static int count = 9;
public native static String getStringFromC();
public native String getString2FromC(int i);
// 访问属性，返回修改之后的属性内容
public native String accessField();
public native void accessStaticField();
public native void accessMethod();
public native void accessStaticMethod();
public static void main(String[] args) {
String text = getStringFromC();
System.out.println(text);
JniTest t = new JniTest();
text = t.getString2FromC(6);
System.out.println(text);
System.out.println("key修改前："+t.key);
t.accessField();
System.out.println("key修改后："+t.key);
System.out.println("count修改前："+count);
t.accessStaticField();
System.out.println("count修改后："+count);
t.accessMethod();
t.accessStaticMethod();
}
// 产生指定范围的随机数
public int genRandomInt(int max){
System.out.println("genRandomInt 执行了...");
return new Random().nextInt(max);
}
// 产生UUID字符串
public static String getUUID(){
return UUID.randomUUID().toString();
}
// 加载动态库
static{
System.loadLibrary("jni_study");
}
}
我们想在jni中访问该类中的属性key，并修改。
// 修改属性key的字符串
JNIEXPORT jstring JNICALL Java_com_tz_jni_TestNative_accessField(JNIEnv * env, jobject obj){
//得到class
jclass cls = (*env)->GetObjectClass(env, obj);
//jfieldID
//签名：类型的简称
//属性，方法
jfieldID fid = (*env)->GetFieldID(env, cls, "key", "Ljava/lang/String;");
//获取key属性的值
//注意：key为基本数据类型，规则如下
//(*env)->GetIntField(); (*env)->Get<Type>Field();
jstring jstr = (*env)->GetObjectField(env, obj, fid);
//jstring转为 C/C++字符串
char *str = (*env)->GetStringUTFChars(env, jstr, NULL);
//拼接字符串
char text[50] = "super ";
strcat(text,str);
//拼接完成之后，从C字符串转为jstring
jstr = (*env)->NewStringUTF(env, text);
//修改key的属性
//注意规则：Set<Type>Field
(*env)->SetObjectField(env, obj, fid, jstr);
return jstr;
}
7.1.2访问静态属性
//count属性+10
JNIEXPORT void JNICALL Java_com_tz_jni_TestNative_accessStaticField(JNIEnv * env, jobject obj) {
//jclass
jclass cls = (*env)->GetObjectClass(env, obj);
//jfieldID
jfieldID fid = (*env)->GetStaticFieldID(env, cls, "count", "I");
//获取静态属性的值
//规则：GetStatic<Type>Field
jint count = (*env)->GetStaticIntField(env, cls, fid);
count += 10;
//修改属性的值
//规则：SetStatic<Type>Field
(*env)->SetStaticIntField(env, cls, fid, count);
}
7.2 c/c++访问java方法
回顾一下java反射，一般分为3个步骤：
1）加载calss（字节码），获取class的对象；
2）获取对应的方法或属性；
3）修改属性，或执行方法。
例如：
有java类Reflect：
public class Reflect {
public void print(String s) {
System. out.println(s);
}
}
另一个Test类来反射此类，执行print(String)方法:
public class Test {
public static void main(String[] args) {
try {
Class clazz = Test.class.getClassLoader().loadClass("Reflect");
Method method = clazz.getDeclaredMethod("print", new Class[] {String.class});
method.invoke(clazz.newInstance(), new String[] {"java反射"});
} catch (Exception e) {
e.printStackTrace();
}
}
}
控制台输出：java反射
接下来看c/c++中的反射。
而对一个方法，其签名就是其参数类型签名和返回值类型签名的字符串，其形式如下：
**（类型签名1类型签名2...）返回值类型签名 **
下面看看两个例子：
方法 1）：public string addTail(String tail, int index)
方法签名为：(Ljava/util/String;I)Ljava/util/String;
方法 2）：public int addValue(int index, String value,int[] arr)
方法 签名为：(ILjava/util/String;[I)I
也可以通过命令，获取属性与方法签名。在class文件夹中，输入：javap -s -p 类名
1）访问java方法
// 借用java的api产生指定大小的随机数
JNIEXPORT void JNICALL Java_com_tz_jni_TestNative_accessMethod(JNIEnv * env, jobject obj) {
//jclass
jclass cls = (*env)->GetObjectClass(env, obj);
//jmethodID
jmethodID mid = (*env)->GetMethodID(env, cls, "genRandomInt", "(I)I");
//调用方法，产生了一个随机数
//规则：Call<Type>Method 返回值类型
jint random = (*env)->CallIntMethod(env, obj, mid, 200);
//打印出来看看
//FILE *fp = fopen("D://log.txt", "w");
//int转为字符串
char str[50];
sprintf(str, "%d", random);
fputs(str, fp);
fclose(fp);
}
2）访问静态方法
//借用java api 产生一个UUID字符串，作为文件的名称
JNIEXPORT void JNICALL Java_com_tz_jni_TestNative_accessStaticMethod(JNIEnv * env, jobject cls){
//如果native方法为static，jobject为子类jclass的实例，也就是native方法所属的类的Class实例
//jclass
//jclass cls = (*env)->GetObjectClass(env, obj);
//jmethodID
jmethodID mid = (*env)->GetStaticMethodID(env, cls, "getUUID", "()Ljava/lang/String;");
//调用
//规则：CallStatic<Type>Method
jstring uuid = (*env)->CallStaticObjectMethod(env, cls, mid);
//jstring转为C字符串
char *uuid_str = (*env)->GetStringUTFChars(env, uuid, NULL);
char filename[100] = {0};
sprintf(filename, "D://%s.txt", uuid_str);
FILE *fp = fopen(filename, "w");
fputs(uuid_str, fp);
fclose(fp);
}
3）访问构造方法
//使用java.util.Date产生一个当前时间时间戳
JNIEXPORT jobject JNICALL Java_com_tz_jni_TestNative_accessConstructor(JNIEnv * env, jobject obj){
//Date jclass
jclass cls = (*env)->FindClass(env, "java/util/Date");
//构造方法jmethodID
jmethodID contructor_mid = (*env)->GetMethodID(env, cls, "<init>","()V");
//实例化一个Date对象
jobject date_obj = (*env)->NewObject(env, cls, contructor_mid);
//调用getTime方法
jmethodID mid = (*env)->GetMethodID(env, cls, "getTime", "()J");
jlong time = (*env)->CallLongMethod(env, date_obj, mid);
//jlong -> 字符串
FILE *fp = fopen("D://log.txt", "w");
char str[50];
sprintf(str, "%lld", time);
fputs(str, fp);
fclose(fp);
return date_obj;
}
4）调用父类的方法
JNIEXPORT void JNICALL Java_com_tz_jni_TestNative_callNonvirtualMethod(JNIEnv * env, jobject obj) {
//获取一个Man对象
jclass cls = (*env)->GetObjectClass(env, obj);
jfieldID fid = (*env)->GetFieldID(env, cls, "human", "Lcom/tz/jni/Human;");
jobject human_obj = (*env)->GetObjectField(env, obj, fid);
//执行sayHi方法
jclass human_cls = (*env)->FindClass(env, "com/tz/jni/Human");//注意：传父类的类名
jmethodID mid = (*env)->GetMethodID(env, human_cls, "sayHi", "()Ljava/lang/String;");
//执行子类覆盖的方法
//jstring jstr = (*env)->CallObjectMethod(env, human_obj, mid);
//执行父类的方法
jstring jstr = (*env)->CallNonvirtualObjectMethod(env, human_obj, human_cls, mid);
//jstring->char*
char * str = (*env)->GetStringUTFChars(env, jstr, NULL);
FILE *fp = fopen("D://log.txt", "w");
fputs(str, fp);
fclose(fp);
}
7.3 实战：中文字符串乱码
JNIEXPORT jstring JNICALL Java_com_tz_jni_TestNative_chineseChars(JNIEnv * env, jobject obj,jstring jstr) {
//java中传入的中文->C字符串
/*char * str = (*env)->GetStringUTFChars(env, jstr, NULL);
FILE *fp = fopen("D://log.txt", "w");
fputs(str, fp);
fclose(fp);*/
//C字符串->jstring
char *cstr = "我说中文";
//jstring j_str = (*env)->NewStringUTF(env, cstr);
//借用Java的转码API，返回GB2312中文编码字符串
//使用这个构造方法，完成转码
//public String(byte bytes[], String charsetName)
//执行这个构造方法需要三个东西
//1.jmethodID
//2.byte数组(jbyteArray)参数
//3.charsetName参数(jstring)
//String类的jclass
jclass str_cls = (*env)->FindClass(env, "java/lang/String");
jmethodID constructor_mid = (*env)->GetMethodID(env, str_cls, "<init>", "([BLjava/lang/String;)V");
//char * -> char[] ->jbyteArray -> jbyte *
jbyteArray bytes = (*env)->NewByteArray(env, strlen(cstr));
//bytes数组赋值
(*env)->SetByteArrayRegion(env, bytes, 0, strlen(cstr), cstr);
//charsetName="GB2312"
jstring charsetName = (*env)->NewStringUTF(env, "GB2312");
//返回GB2312中文编码jstring
return (*env)->NewObject(env, str_cls, constructor_mid, bytes, charsetName);
}
