前面介绍了JNI的基本规范以及JNI的接口的生成过程。本文通过一个jni_test 应用实践操作JNI的接口各种典型应用。
jni_test从jni的字符串,数组,基本类型,自定义类,C回调java静态方法,C回调Java的实例方法,C访问Java的静态变量,C访问Java的实例变量,Java传内存数据给C,C传内存数据给Java 共10个demo演示jni各种典型应用场景。
一、UI设计
通过修改active_main.xml(为了简单起见采用相对布局),或者直接使用design工具拖动布局(先拖一个layout线下布局,再在该布局上排上控件,类似MFC的UI设计原理),UI效果如下。
jni_test的UI界面
二、JIN接口的定义
Java JNI接口声明如下:
public native String stringFromJNI(String src);
public native String CallbackFuncTest();
public native int CallbackClassTest();
public native int CallbackStaticVarTest();
public native int CallbackVarTest(TestNative obj);
public native int add(int x,int y);
public native int [] updateArray(int [] src,int len);
public native void passmem2C(int [] src,int len);
public native int [] getmem2C();
三、在native层jni实现如下:
extern "C" JNIEXPORT jstring JNICALL
Java_com_example_jni_1test_MainActivity_stringFromJNI(
JNIEnv* env,
jobject /* this */,
jstring src) {
std::string hello = "Hello3 from C++";
const char* native_string = env->GetStringUTFChars(src, NULL);
std::string temp(native_string);
std::string dst = hello+temp;
env->ReleaseStringUTFChars(src, native_string);
return env->NewStringUTF(dst.c_str());
}
//回调java 静态的方法
extern "C" JNIEXPORT jstring Java_com_example_jni_1test_MainActivity_CallbackFuncTest(
JNIEnv* env,
jobject /* this */ ){
jclass mJclass;
jstring mJstring;
jmethodID mJStaticmethodID;
//1.从classpath路径下搜索ClassMethod这个类,并返回该类的Class对象
int i = 0;
mJclass = env->FindClass("com/example/jni_test/TestNative"); //JNIEnv*, const char*
if (mJclass == NULL) {
LOGI("test","callJavaStaticMethod==>>mJclass==NULL==>>%s", "");
return env->NewStringUTF("CallbackTest is failed");
}
// 2、从clazz类中查找callStaticMethod方法
mJStaticmethodID = env->GetStaticMethodID(mJclass,
"settext",
"(Ljava/lang/String;)V"); //JNIEnv*, jclass, const char*, const char*
if (mJStaticmethodID == NULL) {
LOGI("test","=====>>>can not foud callStaticMethod");
return env->NewStringUTF("CallbackFuncTest is failed");
}
mJstring= env->NewStringUTF("settext is now");
env->CallStaticVoidMethod(mJclass, mJStaticmethodID, mJstring);
// 删除局部引用
env->DeleteLocalRef(mJstring);
env->DeleteLocalRef(mJclass);
return env->NewStringUTF("CallbackFuncTest is now");
}
//回调java中的类
extern "C" JNIEXPORT jint Java_com_example_jni_1test_MainActivity_CallbackClassTest(
JNIEnv* env,
jobject /* this */ ) {
jclass mJclass = NULL;
jmethodID jmethodID_Construct; //构造方法ID
jmethodID jmethodID_Method_Instance; //方法的ID
jmethodID jmethodID_Method_Instance2; //方法的ID
jobject jobjectMyClass; //类的实例
//1、从classpath路径下搜索ClassMethod这个类,并返回该类的Class对象
mJclass = env->FindClass("com/example/jni_test/TestNative");
if (mJclass == NULL) {
printf("====FindClass not found \n");
return 0;
}
// 2、获取类的默认构造方法ID
jmethodID_Construct = env->GetMethodID(mJclass, "<init>", "(I)V");
if (jmethodID_Construct == NULL) {
printf("GetMethodID not found ==>>jmethodID_Construct");
return 0;
}
// 3、查找实例方法的ID
jmethodID_Method_Instance = env->GetMethodID(mJclass,
"setnum", "(I)V");
if (jmethodID_Method_Instance == NULL) {
return 0;
}
// 4、创建该类的实例 调用无参构造方法 如果其它构造方法,后面可传参数
jobjectMyClass = env->NewObject(mJclass, jmethodID_Construct,100); //JNIEnv*, jclass, jmethodID, ...
if (jobjectMyClass == NULL) {
return 0;
}
// 5、调用对象的实例方法
env->CallVoidMethod(jobjectMyClass, jmethodID_Method_Instance,
100); //JNIEnv*, jobject, jmethodID, ...
// 3、查找实例方法的ID
jmethodID_Method_Instance2 = env->GetMethodID(mJclass,
"getnum", "()I");
if (jmethodID_Method_Instance2 == NULL) {
return 0;
}
int ret;
ret=env->CallIntMethod(jobjectMyClass, jmethodID_Method_Instance2); //JNIEnv*, jobject, jmethodID, ...
// 删除局部引用
env->DeleteLocalRef(jobjectMyClass);
return ret;
}
//回调java中的类中静态变量
extern "C" JNIEXPORT jint Java_com_example_jni_1test_MainActivity_CallbackStaticVarTest(
JNIEnv* env,
jobject /* this */ ) {
jclass clazz;
jfieldID fid;
int test;
//1.获取ClassField类的Class引用
clazz = env->FindClass("com/example/jni_test/TestNative");
if (clazz == NULL) { // 错误处理
return 0;
}
//2.获取ClassField类静态变量test的属性ID
fid = env->GetStaticFieldID(clazz, "iVar", "I");
if (fid == NULL) {
return 0;
}
// 3.获取静态变量test的值
test = env->GetStaticIntField(
clazz,
fid);
LOGI("test","test = %d\n", test);
// 4.修改静态变量num的值
jint ret = 55;
env->SetStaticIntField(clazz, fid, ret);
test = env->GetStaticIntField(
clazz,
fid);
// 删除属部引用
env->DeleteLocalRef(clazz);
return test;
}
extern "C" JNIEXPORT int Java_com_example_jni_1test_MainActivity_CallbackVarTest(
JNIEnv* env,
jobject /* this */,jobject obj) {
jclass clazz;
jfieldID fid;
jstring j_str;
jstring j_newStr;
const char *c_str = NULL;
// 1.获取AccessField类的Class引用
clazz = env->GetObjectClass(obj);
if (clazz == NULL) {
return 0;
}
// 2. 获取AccessField类实例变量str的属性ID
fid = env->GetFieldID(clazz, "str", "Ljava/lang/String;");
if (clazz == NULL) {
return 0;
}
// 3. 获取实例变量str的值
j_str = static_cast<jstring>(env->GetObjectField(obj, fid)); //JNIEnv*, jobject, jfieldID
if (j_str == NULL) {
return 0;
}
// 4. 将unicode编码的java字符串转换成C风格字符串
c_str = env->GetStringUTFChars(j_str, NULL); //JNIEnv*, jstring, jboolean*
if (c_str == NULL) {
return 0;
}
LOGI("test","In C--->ClassField.str = %s\n", c_str);
env->ReleaseStringUTFChars(j_str, c_str); //JNIEnv*, jstring, const char*
// 5. 修改实例变量str的值
j_newStr = env->NewStringUTF("This is new String");
if (j_newStr == NULL) {
return 0;
}
env->SetObjectField(obj, fid, j_newStr); //JNIEnv*, jobject, jfieldID, jobject
// 6.删除局部引用
env->DeleteLocalRef(clazz); //JNIEnv*, jobject
env->DeleteLocalRef(j_str); //JNIEnv*, jobject
env->DeleteLocalRef(j_newStr); //JNIEnv*, jobject
//env->DeleteLocalRef(env,fid);//JNIEnv*, jobject 返回的非object,不能使用 DeleteLocalRef
//使用NewObject就会返回创建出来的实例的局部引用 可 DeleteLocalRef
return 1;
}
extern "C" JNIEXPORT jint JNICALL Java_com_example_jni_1test_MainActivity_add
(JNIEnv *env, jobject, jint x, jint y){
int x1 = x;
int y1 = y;
int sum = (x1+y1)*200;
__android_log_print(ANDROID_LOG_DEBUG,"test","hello5 world");
LOGD("test","hello sum is %d",sum);
//printf("hello3 world");
// std::cout<<"hello4 world"<<std::endl;
return sum;
}
extern "C" JNIEXPORT jintArray JNICALL Java_com_example_jni_1test_MainActivity_updateArray
(JNIEnv *env, jobject, jintArray src,jint len)
{
jintArray dst;
jint *cPArray = env->GetIntArrayElements(src, NULL);
if (cPArray == NULL) {
return 0; // JVM复制原始数据到缓冲区失败
}
// jint i;
for(int i=0;i<len;i++)
{
cPArray[i]=cPArray[i]+100;
LOGD("test","cPArray %d",cPArray[i]);
}
//给java层返回数组方式1
int cInts[len]; //定义一个数组
for (int i = 0; i < len; i++) {
cInts[i] = cPArray[i];
}
dst = env->NewIntArray(len);
if (dst == NULL) {
return NULL; /* out of memory error thrown */
}
//move from the temp structure to the java structure 将native数组转换为java层数组
env->SetIntArrayRegion(dst, 0, sizeof(cInts) / sizeof(cInts[0]),
cInts);
env->ReleaseIntArrayElements(src, cPArray, 0); // 释放可能复制的缓冲区
return dst;
}
extern "C" JNIEXPORT void JNICALL Java_com_example_jni_1test_MainActivity_passmem2C
(JNIEnv *env, jobject, jintArray src,jint len) {
jintArray dst;
int *cPArray = env->GetIntArrayElements(src, NULL);
if (cPArray == NULL) {
return ; // JVM复制原始数据到缓冲区失败
}
for(int i=0;i<len;i++)
{
*(cPArray+i)=i;
LOGD("test","cPArray %d", *(cPArray+i));
}
env->ReleaseIntArrayElements(src, cPArray, 0); // 释放可能复制的缓冲区
}
extern "C" JNIEXPORT jintArray JNICALL Java_com_example_jni_1test_MainActivity_getmem2C
(JNIEnv *env, jobject){
jintArray dst;
int *p = (int *)malloc(10);
if(!p)
{
LOGD("test","malloc is failed");
}
for(int i=0;i<10;i++)
{
*(p+i)=i;
LOGD("test","navtive cPArray %d", *(p+i));
}
dst = env->NewIntArray(10);
if (dst == NULL) {
return NULL; /* out of memory error thrown */
}
//move from the temp structure to the java structure 将native数组转换为java层数组
env->SetIntArrayRegion(dst, 0, 10,p);
return dst;
}
需要完整工程或者了解更多更详细信息请关注公众号:AV_Chat