#include <stdio.h>

#include <jni.h>
#include "JNIDemo.h"


JNIEXPORT jint JNICALL Java_JNIDemo_sayHello
  (JNIEnv *env, jclass cls, jstring name) {
      int  ret = 100;  // just for a test;
      char* str_name=(char*) env->GetStringUTFChars(name,JNI_FALSE);

      printf("cpp :  hello %s\n",(char*)str_name);

      env->ReleaseStringUTFChars(name,str_name);

      return ret;
  }

JNIEXPORT jstring JNICALL Java_JNIDemo_sayGoodbye
  (JNIEnv *env, jclass cls, jstring name) {
	  /* 从jstring中获取字符串 ,后面详细介绍*/	
      char* str_name=(char*) env->GetStringUTFChars(name,JNI_FALSE);

      printf("call sayGoodbye  %s\n",str_name);
     
      env->ReleaseStringUTFChars(name,str_name);
      return 0;
  }

JNIEXPORT jint JNICALL Java_JNIDemo_sayHello
  (JNIEnv *env, jclass cls, jstring name) {
      int  ret = 100;  // just for a test;
      /* 第二个参数指定是不是要拷贝，还是直接引用 */
      char* str_name=(char*) env->GetStringUTFChars(name,JNI_FALSE);

      printf("cpp :  hello %s\n",(char*)str_name);
      
	  /* 使用之后切记要释放，否则会造成内存的泄露 */	
      env->ReleaseStringUTFChars(name,str_name);

      return ret;
  }

JNIEXPORT jstring JNICALL Java_JNIDemo_sayGoodbye
  (JNIEnv *env, jclass cls, jstring name) {

      char* str_name=(char*) env->GetStringUTFChars(name,JNI_FALSE);

      printf("call sayGoodbye  %s\n",str_name);

      env->ReleaseStringUTFChars(name,str_name);

	  /* 使用 字符串构造 jstring对象 */
      jstring str =  env->NewStringUTF("hahahaha");

      return str;
  }

JNIEXPORT jobject JNICALL Java_com_oracle_estt_sc_db_impl_SCQueryODBC__1getCustomer
(JNIEnv *env, jobject, jobject customer){

    jmethodID methodId; 
    //获得customer对象的句柄
    jclass cls_objClass=env->GetObjectClass(customer); 
    //获得customer对象中特定方法getName的id 
    methodId=env->GetMethodID(cls_objClass,"getName","()Ljava/lang/String;");
    //调用customer对象的特定方法getName
    jstring js_name=(jstring)env->CallObjectMethod(customer,methodId,NULL);

    ...
}

JNIEXPORT jobject JNICALL Java_com_oracle_estt_sc_db_impl_SCQueryODBC__1getCustomer
(JNIEnv *env, jobject, jobject customer){

    ......

        //发现java Customer类，如果失败，程序返回
        jclass clazz = env->FindClass("com/oracle/estt/sc/busi/Customer"); 
    if(clazz == 0) 
        return 0; 
    //为新的java类对象obj分配内存 
    jobject obj = env->AllocObject(clazz); 
    //发现类中的属性，如果失败，程序返回 
    jfieldID fid_id = env->GetFieldID(clazz,"customerID","I"); 
    if (fid_id == 0) 
        return 0;
    jfieldID fid_name = env->GetFieldID(clazz,"name","Ljava/lang/String;"); 
    if (fid_name == 0) 
        return 0;
    ......

        env->SetIntField(obj, fid_id, 1
        env->SetObjectField(obj, fid_name, jname);

    ......

        return obj;

}

JNIEXPORT void JNICALL Java_com_oracle_estt_sc_db_impl_SCInsertODBC__1insertCustomeRequest___3Lcom_oracle_estt_sc_busi_CustomerRequest_2
(JNIEnv *env, jobject, jobjectArray oa){

    ...... 

        //声明customerrequest对象
        jobject o_customer;

    int i;
    jmethodID methodId; 
    jint size=env->GetArrayLength(oa);

    _tmp_bind[0]= (char *)malloc(size*sizeof(int));
    _tmp_bind[1]= (char *)malloc(size*sizeof(char)*( 20 + 1));

    ...

        //将输入数组的数据拷贝到临时数组中去
        for(i=0;i<size;i++){
            //从数组中获得customerrequest对象
            o_request=env->GetObjectArrayElement(oa,i);
            //获得customerrequest对象的句柄
            jclass cls_objClass=env->GetObjectClass(o_request);

            //获得customerrequest对象的特定方法getCustomerID的id
            methodId=env->GetMethodID(cls_objClass,"getCustomerID","()I");
            //调用customerrequest对象的特定方法getCustomerID
            int_customerID=env->CallIntMethod(o_request,methodId,NULL); 
            //获得customerrequest对象中特定方法getTelNum的id 
            methodId=env->GetMethodID(cls_objClass,"getTelNum","()Ljava/lang/String;");
            //调用customerrequest对象的特定方法getTelNum
            str_telNum=(jstring)env->CallObjectMethod(o_request,methodId,NULL); 

            ...

                //将用户id拷贝到临时数组
                memcpy(_tmp_bind[0]+i*sizeof(int),&int_customerID,sizeof(int));

            //将电话号码拷贝到临时数组，如果电话号码字符串超长，报错返回
            if(sizeof(char)*strlen(chr_tel)<=sizeof(char)*( 20 + 1)){
                memcpy(_tmp_bind[1]+i*sizeof(char)*( 20+1 ),chr_tel,strlen(chr_tel)+1);
            }else{
                printf("%s too long!\n",chr_tel);
                return;
            }

            ...

        }

        ...

}

JNIEXPORT jobjectArray JNICALL Java_com_oracle_estt_sc_db_impl_SCQueryODBC__1getCustomerRequest
(JNIEnv *env, jobject, jint customerid){

    ......

        //声明存放查询结果的objectarray
        jobjectArray jo_array = env->NewObjectArray(MAX_LINE,env->FindClass("com/oracle/estt/sc/busi/CustomerRequest"), 0); jobject obj;
    //发现java Customerrequest类，如果失败，程序返回
    jclass clazz = env->FindClass("com/oracle/estt/sc/busi/CustomerRequest"); 
    if(clazz == 0) 
        return 0;

    while ((rc = SQLFetch(hstmt)) == SQL_SUCCESS ||rc == SQL_SUCCESS_WITH_INFO) {

        obj = env->AllocObject(clazz);

        jfieldID fid_customerID = env->GetFieldID(clazz,"customerID","I"); 
        if (fid_customerID == 0) 
            return 0;

        jfieldID fid_priority = env->GetFieldID(clazz,"priority","I"); 
        if (fid_priority == 0) 
            return 0;

        ...

            env->SetIntField(obj, fid_customerID, col_customerID);

        env->SetIntField(obj, fid_priority, col_priority);

        ...

            //将对象obj添加到object array中
            if(j<MAX_LINE){
                env->SetObjectArrayElement(jo_array, j, obj);
            }else{
                break;
            }

    }

    return jo_array;

}

/*
 *  hello.cpp jvav JNI 测试用 动态库源文件
 *           by codewang 2017.7.17 @heu
*/

#include <stdio.h>
#include <stdlib.h>

/*
 *  对动态库的一些封装和对java JNI库函数的支持
*/
#include <jni.h>
#include "JNIDemo.h"


/* 对于java中的int add(int int) */
JNIEXPORT jint JNICALL Java_JNIDemo_add
  (JNIEnv *env, jclass cls, jint a, jint b)
  {
      /* 基本数据类型，直接使用 */
      return a+b;
  }

/* 对应java中的 int[] sum(int[] ,int[]) */
JNIEXPORT jintArray JNICALL Java_JNIDemo_sum
  (JNIEnv *env, jclass cls, jintArray a, jintArray b)
  {
      jint *arr_a,*arr_b;
      jint len = env->GetArrayLength(a);
      printf("arr len = %d\n",len);
      // 注意，这里不释放会造成内存泄漏。
      // 一般我们在java层提供一个释放native方法，在cpp中释放内存
      jint* ret = new jint[len];

      arr_a = env->GetIntArrayElements(a,JNI_FALSE);
      arr_b = env->GetIntArrayElements(b,JNI_FALSE);

      for(int i=0;i<len;i++) {
          ret[i] = arr_a[i] + arr_b[i];
      }

      /* 构造 jintArray返回给java */
      jintArray jintarray = env->NewIntArray(len);
      env->SetIntArrayRegion(jintarray,0,len,ret);

      return jintarray;
  }

/* 对应java中的 String subString(String ,int ,int) */
JNIEXPORT jstring JNICALL Java_JNIDemo_subString
  (JNIEnv *env, jclass cls, jstring str, jint start, jint len)
  {
      /* 从jstring中获取字符串 */
      char *src = (char*)env->GetStringUTFChars(str,JNI_FALSE);
      /* 分离子串 */
      char* subStr = new char[len+1];

      for(jint i=start,j=0;j<len;i++,j++) {
           subStr[j] = src[i];
      }
      subStr[len] = '\0';

      /* 封装为jstring 返回 */
      jstring retString = env->NewStringUTF(subStr);

      /* 释放 */
      env->ReleaseStringUTFChars(str,src);
      return retString;
  }

/* 对应java中的 Student changeStudentInfo(Student ) */
JNIEXPORT jobject JNICALL Java_JNIDemo_changeStudentInfo
  (JNIEnv *env, jclass cls, jobject student)
  {
      /* 先获得类 */
      jclass classStudent = env->GetObjectClass(student);

      /* 获得方法 */
      jmethodID getName = env->GetMethodID(classStudent,
                                           "getName",
                                           "()Ljava/lang/String;");

      /* 执行方法 */
      jstring name = (jstring)env->CallObjectMethod(student,getName,NULL);
      char *src = (char*)env->GetStringUTFChars(name,JNI_FALSE);
      printf("int cpp  ：  get name = %s\n",src);


      /* 返回新对象 */
      jobject newObject = env->AllocObject(classStudent);
      /* 可以通过调用方法设置属性，也可以直接设置 */

      jfieldID nameID = env->GetFieldID(classStudent,"name","Ljava/lang/String;");
      jfieldID ageID  = env->GetFieldID(classStudent,"age","I");

      jstring codewang = env->NewStringUTF("codewang");

      env->SetObjectField(newObject,nameID,codewang);
      env->SetIntField(newObject,ageID,22);

      return newObject;

  }


JNIEXPORT jobjectArray JNICALL Java_JNIDemo_changeAll
  (JNIEnv *, jclass, jobjectArray)
  {
      /* 和 intArray操作 一样，省略了。。。 */
  }

/* 假设下面时在c中实现的本地方法，方法体忽略，我们只关注参数类型 */
jint func1(jint ,jint){}
jintArray func2(jIntArray){}
jstring func3(jstring){}
jobject func4(jobject){}
jObjectArray func5(jObjectArray){}

/* 定义方法映射的数组 */
/*
 *  关于这些参数符号表，怎么定义，实质上在我们用javah生成的头文件里有
 *  大概规则为： 
 *  1. (参数列表)返回值
 *  2. [ 代表数组
 *  3. L 代表对象
 *  4. 基本数据类型由一个字母代替，见下面的表
 *  5. String对象比较特殊，要用java/lang/String 表示
 *  6. 其他对象均被转化为Onject类
 *  我们再看看这个JNINativeMethod结构体如何定义的：
 *  typedef struct {
 *    char *name;        // java中对应的方法名
 *   char *signature;    // 参数返回值符号表 
 *   void *fnPtr;        // c中的对应的函数指针
 *  } JNINativeMethod;
*/
static const JNINativeMethod gMethods[] = {
    { "java_func1" , "(II)I"  , (void*)func1 },
    { "java_func2" , "([I)[I" , (void*)func2 },
    { "java_func3" , "(Ljava/lang/String)Ljava/lang/String" , (void*)func3 },
    { "java_func4" , "(LObject)Lobject" , (void*)func4 } ,
    { "java_func5" , "([LObject)[LObject" , (void*)func5}
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
{
	/* 在前面我们实验时，都知道第一个参数时一个env，如果没有这个函数，jvm默认给我们最
     *老版本的JNI ，但是有了初始化函数，我们可以选择JNI版本。	
    */
    JNIEnv * env;
    vm->GetEnv((void**)&env,JNI_VERSION_1_4);  // 获取版本1.4
    
    /* 注册方法 */
    /* 1. 注册方法，要注册到哪个类？ */
    jclass clazz = env->FindClass("JNIDemo");
    /* 2. 注册到这个类 */
    env->RegisterNatives(clazz,gMethods,5);
    
    /* 可以想象一下：
     * 这中方法实质上和前面一种方法的区别就在于，改了一个env，那么我们在c程序中更改了env，JVM却不知道啊，
     * 所以我们要把选择的版本告诉JVM
    */
    return JNI_VERSION_1_4;
}


/*
*  除了Onload 之外 ，还有与之对应的OnUnLoad,它在动态库卸载之前被调用，可以联想下c的动态库连接技术
*  还有很多函数供我们使用，可以在jni.h中看到他们的定义。
*/