JNI编程<三>

最新推荐文章于 2018-11-23 10:19:50 发布

Ragnaro

最新推荐文章于 2018-11-23 10:19:50 发布

阅读量4.1k

点赞数

分类专栏： Android

Android 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

转自：http://blog.csdn.net/qinjuning/article/details/7607214

一、在Native层返回一个字符串

Java层原型方法：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     public native void getAJNIString();  
     ...  
 }     

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    getAJNIString 
  * Signature: ()Ljava/lang/String; 
  */   
 //返回字符串  
 JNIEXPORT jstring JNICALL Java_com_feixun_jni_HelloJni_getAJNIString(JNIEnv * env, jobject obj)  
 {  
     jstring str = env->newStringUTF("HelloJNI");  //直接使用该JNI构造一个jstring对象返回  
     return str ;  
 }  

二、在Native层返回一个int型二维数组(inta[ ][ ])

Java层原型方法：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     //参数代表几行几列数组 ，形式如：int a[dimon][dimon]  
     private native int[][] getTwoArray(int dimon) ;   
     ...  
 }     

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    getTwoArray 
  * Signature: (I)[[I 
  */  
 //通过构造一个数组的数组， 返回 一个二维数组的形式  
 JNIEXPORT jobjectArray JNICALL Java_com_feixun_jni_HelloJni_getTwoArray  
   (JNIEnv * env, jobject object, jint dimion)  
 {  
       
     jclass intArrayClass = env->FindClass("[I"); //获得一维数组 的类引用，即jintArray类型  
     //构造一个指向jintArray类一维数组的对象数组，该对象数组初始大小为dimion  
     jobjectArray obejctIntArray  =  env->NewObjectArray(dimion ,intArrayClass , NULL);  
   
     //构建dimion个一维数组，并且将其引用赋值给obejctIntArray对象数组  
     for( int i = 0 ; i< dimion  ; i++ )  
     {  
         //构建jint型一维数组  
         jintArray intArray = env->NewIntArray(dimion);  
   
         jint temp[10]  ;  //初始化一个容器，假设 dimion  < 10 ;  
         for( int j = 0 ; j < dimion ; j++)  
         {  
             temp[j] = i + j  ; //赋值  
         }  
           
         //设置jit型一维数组的值  
         env->SetIntArrayRegion(intArray, 0 , dimion ,temp);  
         //给object对象数组赋值，即保持对jint一维数组的引用  
         env->SetObjectArrayElement(obejctIntArray , i ,intArray);  
   
         env->DeleteLocalRef(intArray);  //删除局部引用  
     }  
   
     return   obejctIntArray; //返回该对象数组  
 }  

三、在Native层操作Java层的类：读取/设置类属性

Java层原型方法：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     //在Native层读取/设置属性值  
     public native void native_set_name() ;  
     ...  
       
     private String name = "I am at Java" ; //类属性  
 }     

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    native_set_name 
  * Signature: ()V  
  */  
 //在Native层操作Java对象，读取/设置属性等  
 JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_native_1set_1name  
   (JNIEnv *env , jobject  obj )  //obj代表执行此JNI操作的类实例引用  
 {  
    //获得jfieldID 以及 该字段的初始值  
    jfieldID  nameFieldId ;  
   
    jclass cls = env->GetObjectClass(obj);  //获得Java层该对象实例的类引用，即HelloJNI类引用  
   
    nameFieldId = env->GetFieldID(cls , "name" , "Ljava/lang/String;"); //获得属性句柄  
   
    if(nameFieldId == NULL)  
    {  
        cout << " 没有得到name 的句柄Id \n;" ;  
    }  
    jstring javaNameStr = (jstring)env->GetObjectField(obj ,nameFieldId);  // 获得该属性的值  
    const char * c_javaName = env->GetStringUTFChars(javaNameStr , NULL);  //转换为 char *类型  
    string str_name = c_javaName ;    
    cout << "the name from java is " << str_name << endl ; //输出显示  
    env->ReleaseStringUTFChars(javaNameStr , c_javaName);  //释放局部引用  
   
    //构造一个jString对象  
    char * c_ptr_name = "I come from Native" ;  
      
    jstring cName = env->NewStringUTF(c_ptr_name); //构造一个jstring对象  
   
    env->SetObjectField(obj , nameFieldId , cName); // 设置该字段的值  
 }  

四、在Native层操作Java层的类：回调Java方法

Java层原型方法：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     //Native层回调的方法实现  
     public void callback(String fromNative){       
         System.out.println(" I was invoked by native method  ############# " + fromNative);  
     };  
     public native void doCallBack(); //Native层会调用callback()方法  
     ...   
       
     // main函数  
     public static void main(String[] args)   
     {  
         new HelloJni().ddoCallBack();  
     }     
 }     

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    doCallBack 
  * Signature: ()V 
  */  
 //Native层回调Java类方法  
 JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_doCallBack  
   (JNIEnv * env , jobject obj)  
 {  
      //回调Java中的方法  
   
     jclass cls = env->GetObjectClass(obj);//获得Java类实例  
     jmethodID callbackID = env->GetMethodID(cls , "callback" , "(Ljava/lang/String;)V") ;//或得该回调方法句柄  
   
     if(callbackID == NULL)  
     {  
          cout << "getMethodId is failed \n" << endl ;  
     }  
     
     jstring native_desc = env->NewStringUTF(" I am Native");  
   
     env->CallVoidMethod(obj , callbackID , native_desc); //回调该方法，并且传递参数值  
 }  

接下来，我们会操作复杂对象，也就是Java层的类，包括从Native层返回一个类以及传递一个类到Native层去，这儿我们

使用的类非常简单，如下：

Student.java类

[java]view plaincopy 
   
print?
 package com.feixun.jni;  
   
 public class Student  
 {  
     private int age ;  
     private String name ;  
     //构造函数，什么都不做  
     public Student(){ }  
       
     public Student(int age ,String name){  
         this.age = age ;  
         this.name = name ;  
     }  
       
     public int getAge() {  
         return age;  
     }  
     public void setAge(int age) {  
         this.age = age;  
     }  
     public String getName() {  
         return name;  
     }  
     public void setName(String name){  
         this.name = name;  
     }  
       
     public String toString(){  
         return "name --- >" + name + "  age --->" + age ;  
     }  
 }  

五、在Native层返回一个复杂对象(即一个类咯)

Java层的方法对应为：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     //在Native层返回一个Student对象  
     public native Student nativeGetStudentInfo() ;  
     ...   
 }     

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    nativeGetStudentInfo 
  * Signature: ()Lcom/feixun/jni/Student; 
  */  
 //返回一个复杂对象  
 JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_nativeGetStudentInfo  
   (JNIEnv * env, jobject obl)  
 {  
     //关于包描述符，这儿可以是 com/feixun/jni/Student 或者是 Lcom/feixun/jni/Student;   
     //   这两种类型 都可以获得class引用  
     jclass stucls = env->FindClass("com/feixun/jni/Student"); //或得Student类引用  
   
     //获得得该类型的构造函数  函数名为 <init> 返回类型必须为 void 即 V  
     jmethodID constrocMID = env->GetMethodID(stucls,"<init>","(ILjava/lang/String;)V");  
   
     jstring str = env->NewStringUTF(" come from Native ");  
   
     jobject stu_ojb = env->NewObject(stucls,constrocMID,11,str);  //构造一个对象，调用该类的构造函数，并且传递参数  
   
   
     return stu_ojb ;  
 }  

六、从Java层传递复杂对象至Native层

Java层的方法对应为：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     //在Native层打印Student的信息  
     public native void  printStuInfoAtNative(Student stu);  
     ...   
 }  

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    printStuInfoAtNative 
  * Signature: (Lcom/feixun/jni/Student;)V 
  */  
 //在Native层输出Student的信息  
 JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_printStuInfoAtNative  
   (JNIEnv * env, jobject obj,  jobject obj_stu) //第二个类实例引用代表Student类，即我们传递下来的对象  
 {  
       
     jclass stu_cls = env->GetObjectClass(obj_stu); //或得Student类引用  
   
     if(stu_cls == NULL)  
     {  
         cout << "GetObjectClass failed \n" ;  
     }  
     //下面这些函数操作，我们都见过的。O(∩_∩)O~  
     jfieldID ageFieldID = env->GetFieldID(stucls,"age","I"); //获得得Student类的属性id   
     jfieldID nameFieldID = env->GetFieldID(stucls,"name","Ljava/lang/String;"); // 获得属性ID  
   
     jint age = env->GetIntField(objstu , ageFieldID);  //获得属性值  
     jstring name = (jstring)env->GetObjectField(objstu , nameFieldID);//获得属性值  
   
     const char * c_name = env->GetStringUTFChars(name ,NULL);//转换成 char *  
    
     string str_name = c_name ;   
     env->ReleaseStringUTFChars(name,c_name); //释放引用  
       
     cout << " at Native age is :" << age << " # name is " << str_name << endl ;   
 }  

七、最后加个难度，即在Native层返回集合对象(留这儿，以后也好找点)

Java层的对应方法为：

[java]view plaincopy 
   
print?
 public class HelloJni {  
     ...  
     //在Native层返回ArrayList集合   
     public native ArrayList<Student> native_getListStudents();  
     ...   
 }     

Native层该方法实现为 :

[java]view plaincopy 
   
print?
 /* 
  * Class:     com_feixun_jni_HelloJni 
  * Method:    native_getListStudents 
  * Signature: ()Ljava/util/ArrayList; 
  */ //获得集合类型的数组  
 JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_native_getListStudents  
   (JNIEnv * env, jobject obj)  
 {  
     jclass list_cls = env->FindClass("Ljava/util/ArrayList;");//获得ArrayList类引用  
   
     if(listcls == NULL)  
     {  
         cout << "listcls is null \n" ;  
     }  
     jmethodID list_costruct = env->GetMethodID(list_cls , "<init>","()V"); //获得得构造函数Id  
   
     jobject list_obj = env->NewObject(list_cls , list_costruct); //创建一个Arraylist集合对象  
     //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ;  
     jmethodID list_add  = env->GetMethodID(list_cls,"add","(Ljava/lang/Object;)Z");   
     
     jclass stu_cls = env->FindClass("Lcom/feixun/jni/Student;");//获得Student类引用  
     //获得该类型的构造函数  函数名为 <init> 返回类型必须为 void 即 V  
     jmethodID stu_costruct = env->GetMethodID(stu_cls , "<init>", "(ILjava/lang/String;)V");  
   
     for(int i = 0 ; i < 3 ; i++)  
     {  
         jstring str = env->NewStringUTF("Native");  
         //通过调用该对象的构造函数来new 一个 Student实例  
         jobject stu_obj = env->NewObject(stucls , stu_costruct , 10,str);  //构造一个对象  
           
         env->CallBooleanMethod(list_obj , list_add , stu_obj); //执行Arraylist类实例的add方法，添加一个stu对象  
     }  
   
     return list_obj ;  
 }  