NDK 复杂对象传递

1 JAVA层传递复杂对象到JNI
假设我们需要返回的对象如下，是一个Student:

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层接收一个Student对象：

//在Native层输出Student的信息
JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_receiveStuInfoAtNative
  (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 ; 
}

2 Native 层返回一个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 ;
}

3 native层返回一个集合对象

 */ //获得集合类型的数组
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 ;
}

4 native层添加一个callback，回调java方法

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层实现为：

//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); //回调该方法，并且传递参数值
}

5 Native层返回一个整型数组

//通过构造一个数组的数组， 返回 一个二维数组的形式
    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; //返回该对象数组
    }