在java和c之间进行数据传递 之 JNI

                                                                                         JNI:在java和c之间进行数据传递 

【推荐】初学者需要看的JNI开发文档：
http://wiki.jikexueyuan.com/project/jni-ndk-developer-guide/function.html
在java和c之间进行数据传递,两者之间数据的传递有这样几种情况：java和c之间基本数据类型 的交互，java向c传递对象类型，c向java返回对象类型，c调用java类。下面就这样几种情况分类说明。

1、java 向c传递基本数据类型

对于基本数据类型，java和c是相互对应的，所以可以直接使用。它们的对应关系为;

------------------------------------------------------------------------

Java类型　　    本地类型　　 字节(bit)

-------------------------------------------------------------------------

　　

　　boolean　　 jboolean　　 8, unsigned

　　byte　　　　jbyte　　　 　8

　　char　　　　jchar　　　　16, unsigned

　　short　　　 jshort　　　 16

　　int　　　　 jint　　　　 32

　　long　　　　jlong　　　　64

　　float　　　 jfloat　　　 32

　　double　　　jdouble　　　64

　　void　　　　void　　　　 n/a

------------------------------------------------------------------------

2.java向c传递对象类型

对于java传递进来的java对象模型，c要加载java类的原型，根据创建相应的c对象，获取java对象的方法的id,然后调用java对象 的方法。举例说明：比如有个java类customer对象作为jni参数传递到c程序，customer有方法String getName()。

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);

    ...

}

3.c向java返回对象类型

在c程序中首先要创建要返回的java对象，得到每个属性的id，然后给每个属性赋值，最后返回。举例说明：同样是customer对象，有name等属性值，需要在c程序中给每个属性赋值后返回。

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;

}

4.c向java传递一个含有java对象的数组

对于这种情况，先得到数组的大小，接下来取出数组中的对象，取得对象的属性值或者调用对象的方法，将获得值存到本地数组中，然后可以灵活使用这些数 据了。举例说明：java向c传递一个含有多个customer对象的数组，在c中将这个数组的分解出来，存到本地的临时数组中去。

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;

            }

            ...

        }

        ...

}

5.c向java返回一个数组

先创建数组，然后加载java对象，给每个java对象的属性赋值，添加到数组中，最后返回数组。如下例：

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;

}

6.jstring向char* 的转换

jstring不能直接在c程序中使用，需要转换成char*。重要的一点是，在使用完char*之后，一定要记得将其释放，以免发生内存泄漏。如下例：

JNIEXPORT jobjectArray JNICALL Java_com_oracle_estt_sc_db_impl_SCQueryODBC__1getCustomerRequestByCondition

(JNIEnv *env, jobject, jstring condition, jint
customerid){

//将jstring转换为cha*

 char* str_condition=(char*) env->GetStringUTFChars(condition,JNI_FALSE);

......

//释放变量

 env->ReleaseStringUTFChars(condition,str_condition);

......

}

7.char*转换成jstring

这个转换就比较麻烦了，但是在数据库操作时会用到。比如，从数据库查询得到的是char*,但是给对象属性赋值的时候需要用jstring，这是需要用到这种转换。具体如下例：

char* col_timestamp=.....;

//加载string类

 jclass strClass = env->FindClass("Ljava/lang/String;");

 //获得方法id

 jmethodID ctorID = env->GetMethodID(strClass, "", "([BLjava/lang/String;)V");

//将字符串转换为jstring 

  bytes_time = env->NewByteArray(strlen(col_timestamp));

  env->SetByteArrayRegion(bytes_time, 0, strlen(col_timestamp), (jbyte*)col_timestamp);

  jstring js_time = env->NewStringUTF("utf-8");

js_time=(jstring)env->NewObject(strClass, ctorID, bytes_time, js_time)

8.java类的原型获取方法

在c中创建java对象和调用java对象方法时需要用到java类的原型，特别是其方法签名。具体办法是：到java类所在的目录下，键入名命令:

>javap -s -p 包路径.java类名

//补充HashMap JNI 的使用




下面是具体的操作代码

//将java jobject(Hashmap)转为 c++用的Module_Info(用于init,需要分配内存)
static int Jobject2Module_Info(JNIEnv * env, jobject thiz,jobject jobj, Module_Info ** module_info,int * Length,
int useModuleStreamInfo_In,int useModuleStreamInfo_Out,
UseInfoType useinfotype)
{
int ret = 0;

//查看传进来的object是否是空
if (jobj == NULL)
{
LOGD("Jobject2Module_Info jobj == NULL");
return 1;
}

//得到map
jclass jmapclass = env->FindClass("java/util/HashMap");
jmethodID jkeysetmid = env->GetMethodID(jmapclass, "keySet", "()Ljava/util/Set;");
jmethodID jgetmid = env->GetMethodID(jmapclass,"get", "(Ljava/lang/Object;)Ljava/lang/Object;");
jobject jsetkey = env->CallObjectMethod(jobj,jkeysetmid);

//得到key数组(只有key没有value)
jclass jsetclass = env->FindClass("java/util/Set");
jmethodID jtoArraymid = env->GetMethodID(jsetclass, "toArray", "()[Ljava/lang/Object;");
jobjectArray jobjArray = (jobjectArray)env->CallObjectMethod(jsetkey,jtoArraymid);
if(jobjArray == NULL)
{
LOGD("error :jobjArray");
return -1;
}

jsize arraysize = env->GetArrayLength(jobjArray);

LOGD("******************arraysize:%d",(jint)arraysize);

//申请传出的数据信息结构体
Module_Info * pmodule_info = NULL;  //数据信息结构体
int needlength = 0;                 //需要传给下层的长度
int count_info = 0;                 //info标号
if(arraysize > 0)
{
pmodule_info = *module_info;
pmodule_info = (Module_Info *)realloc(pmodule_info,arraysize * sizeof(Module_Info));
for (int i = 0; i< arraysize ;i++)
{
pmodule_info[i].ModuleStreamInfo_In = NULL;
pmodule_info[i].ModuleStreamInfo_Out = NULL;
}
}

//HashMap<Integer,LvsAndroidInfo>
//通过循环key数组得到value
for( int i=0; i < arraysize; i++)
{
//得到key
jobject jkeyobject = env->GetObjectArrayElement(jobjArray,i);
jclass jintclass = env->FindClass("java/lang/Integer");
jmethodID jintId = env->GetMethodID(jintclass, "intValue", "()I");
jint jkey = (jint)env->CallIntMethod(jkeyobject,jintId);
LOGD("jkey:%d",jkey);

//得到value
jobject jvalueobject = (jobject)env->CallObjectMethod(jobj,jgetmid,jkeyobject);
jclass jvalueclass = env->GetObjectClass(jvalueobject);

//stream_id
jmethodID jstream_id = env->GetMethodID(jvalueclass, "getstream_id", "()I");   //最后的参数是括号内参数括号外返回值
if(jstream_id == NULL)
{
LOGD("error :stream_id");
return -1;
}
jint info_stream_id = (jint)env->CallIntMethod(jvalueobject,jstream_id);
LOGD("stream_id:%d",info_stream_id);

//Is_ToNext_Module
jmethodID jIs_ToNext_Module_id = env->GetMethodID(jvalueclass, "getIs_ToNext_Module", "()I");   //最后的参数是括号内参数括号外返回值
if(jIs_ToNext_Module_id == NULL)
{
LOGD("error :Is_ToNext_Module");
return -1;
}
jint info_Is_ToNext_Module = (jint)env->CallIntMethod(jvalueobject,jIs_ToNext_Module_id);
LOGD("Is_ToNext_Module:%d",info_Is_ToNext_Module);

//device_type
jmethodID jdevice_type_id = env->GetMethodID(jvalueclass, "getdevice_type", "()I");   //最后的参数是括号内参数括号外返回值
if(jdevice_type_id == NULL)
{
LOGD("error :device_type");
return -1;
}
jint info_device_type = (jint)env->CallIntMethod(jvalueobject,jdevice_type_id);
LOGD("device_type:%d",info_device_type);

//CodecType
jmethodID jCodecType_id = env->GetMethodID(jvalueclass, "getCodecType", "()I");   //最后的参数是括号内参数括号外返回值
if(jCodecType_id == NULL)
{
LOGD("error :CodecType");
return -1;
}
jint info_CodecType = (jint)env->CallIntMethod(jvalueobject,jCodecType_id);
LOGD("CodecType:%d",info_CodecType);

//timebase_num
jmethodID jtimebase_num_id = env->GetMethodID(jvalueclass, "gettimebase_num", "()I");   //最后的参数是括号内参数括号外返回值
if(jtimebase_num_id == NULL)
{
LOGD("error :timebase_num");
return -1;
}
jint info_timebase_num = (jint)env->CallIntMethod(jvalueobject,jtimebase_num_id);
LOGD("timebase_num:%d",info_timebase_num);

//timebase_den
jmethodID jtimebase_den_id = env->GetMethodID(jvalueclass, "gettimebase_den", "()I");   //最后的参数是括号内参数括号外返回值
if(jtimebase_den_id == NULL)
{
LOGD("error :timebase_den");
return -1;
}
jint info_timebase_den = (jint)env->CallIntMethod(jvalueobject,jtimebase_den_id);
LOGD("timebase_den:%d",info_timebase_den);

//Channel
jmethodID jChannel_id = env->GetMethodID(jvalueclass, "getChannel", "()I");   //最后的参数是括号内参数括号外返回值
if(jChannel_id == NULL)
{
LOGD("error :Channel");
return -1;
}
jint info_Channel = (jint)env->CallIntMethod(jvalueobject,jChannel_id);
LOGD("Channel:%d",info_Channel);

//SampleFormat
jmethodID jSampleFormat_id = env->GetMethodID(jvalueclass, "getSampleFormat", "()I");   //最后的参数是括号内参数括号外返回值
if(jSampleFormat_id == NULL)
{
LOGD("error :SampleFormat");
return -1;
}
jint info_SampleFormat = (jint)env->CallIntMethod(jvalueobject,jSampleFormat_id);
LOGD("SampleFormat:%d",info_SampleFormat);

//SampleRate
jmethodID jSampleRate_id = env->GetMethodID(jvalueclass, "getSampleRate", "()I");   //最后的参数是括号内参数括号外返回值
if(jSampleRate_id == NULL)
{
LOGD("error :SampleRate");
return -1;
}
jint info_SampleRate = (jint)env->CallIntMethod(jvalueobject,jSampleRate_id);
LOGD("SampleRate:%d",info_SampleRate);

//Stream_PixFormat
jmethodID jgetStream_PixFormat_id = env->GetMethodID(jvalueclass, "getStream_PixFormat", "()I");   //最后的参数是括号内参数括号外返回值
if(jgetStream_PixFormat_id == NULL)
{
LOGD("error :Stream_PixFormat");
return -1;
}
jint info_Stream_PixFormat = (jint)env->CallIntMethod(jvalueobject,jgetStream_PixFormat_id);
LOGD("Stream_PixFormat:%d",info_Stream_PixFormat);

//Width
jmethodID jWidth_id = env->GetMethodID(jvalueclass, "getWidth", "()I");   //最后的参数是括号内参数括号外返回值
if(jWidth_id == NULL)
{
LOGD("error :Width");
return -1;
}
jint info_Width = (jint)env->CallIntMethod(jvalueobject,jWidth_id);
LOGD("Width:%d",info_Width);

//Height
jmethodID jHeight_id = env->GetMethodID(jvalueclass, "getHeight", "()I");   //最后的参数是括号内参数括号外返回值
if(jHeight_id == NULL)
{
LOGD("error :Height");
return -1;
}
jint info_Height = (jint)env->CallIntMethod(jvalueobject,jHeight_id);
LOGD("Height:%d",info_Height);

//codec_format
jmethodID jcodec_format_id = env->GetMethodID(jvalueclass, "getcodec_format", "()I");   //最后的参数是括号内参数括号外返回值
if(jcodec_format_id == NULL)
{
LOGD("error :codec_format");
return -1;
}
jint info_codec_format = (jint)env->CallIntMethod(jvalueobject,jcodec_format_id);
LOGD("codec_format:%d",info_codec_format);

//mux_format
jmethodID jmux_format_id = env->GetMethodID(jvalueclass, "getmux_format", "()I");   //最后的参数是括号内参数括号外返回值
if(jmux_format_id == NULL)
{
LOGD("error :mux_format");
return -1;
}
jint info_mux_format = (jint)env->CallIntMethod(jvalueobject,jmux_format_id);
LOGD("mux_format:%d",info_mux_format);

//pts
jmethodID jpts_id = env->GetMethodID(jvalueclass, "getpts", "()J");   //最后的参数是括号内参数括号外返回值
if(jpts_id == NULL)
{
LOGD("error :pts");
return -1;
}
jlong info_pts = (jlong)env->CallLongMethod(jvalueobject,jpts_id);
LOGD("pts:%lld",info_pts);

//dts
jmethodID jdts_id = env->GetMethodID(jvalueclass, "getdts", "()J");   //最后的参数是括号内参数括号外返回值
if(jdts_id == NULL)
{
LOGD("error :dts");
return -1;
}
jlong info_dts = (jlong)env->CallLongMethod(jvalueobject,jdts_id);
LOGD("dts:%lld",info_dts);

//BufLen
jmethodID jBufLen_id = env->GetMethodID(jvalueclass, "getBufLen", "()J");   //最后的参数是括号内参数括号外返回值
if(jBufLen_id == NULL)
{
LOGD("error :BufLen");
return -1;
}
jlong info_BufLen = (jlong)env->CallLongMethod(jvalueobject,jBufLen_id);
LOGD("BufLen:%lld",info_BufLen);

//ActualLen
jmethodID jActualLen_id = env->GetMethodID(jvalueclass, "getActualLen", "()J");   //最后的参数是括号内参数括号外返回值
if(jActualLen_id == NULL)
{
LOGD("error :ActualLen");
return -1;
}
jlong info_ActualLen = (jlong)env->CallLongMethod(jvalueobject,jActualLen_id);
LOGD("ActualLen:%lld",info_ActualLen);

//Buf
jmethodID jBuf_id = env->GetMethodID(jvalueclass, "getBuf", "()[B");   //最后的参数是括号内参数括号外返回值
if(jBuf_id == NULL)
{
LOGD("error :Buf");
return -1;
}
jbyteArray barr_Buf = (jbyteArray)env->CallObjectMethod(jvalueobject,jBuf_id,NULL);
jsize barr_Buf_size = env->GetArrayLength(barr_Buf);
jbyte* info_Buf = env->GetByteArrayElements(barr_Buf,0);
//LOGD("Buf:%s",info_Buf);
LOGD("barr_Buf_size:%d",barr_Buf_size);

/***********
//将上层传过来的value传到Module_Info中,每个模块用到的参数不同
***********/
//传给下层并且是视频流
if (info_Is_ToNext_Module == 1 &&
info_CodecType == CodecType_Video)
{
needlength ++;

pmodule_info[count_info].Is_ToNext_Module = 1;
//header
Module_HeaderInfo_FFmpeg_Video_Codec * pheaderinfo_ffmpeg_video_codec = NULL;
pheaderinfo_ffmpeg_video_codec = new Module_HeaderInfo_FFmpeg_Video_Codec();
pheaderinfo_ffmpeg_video_codec->stream_id = info_stream_id;
pmodule_info[count_info].ModuleHeaderInfo.HeaderInfo = pheaderinfo_ffmpeg_video_codec;
//StreamInfo
Module_StreamInfo * pmodulestreaminfo = NULL;
pmodulestreaminfo = new Module_StreamInfo();
pmodulestreaminfo->stream_id = info_stream_id;
pmodulestreaminfo->CodecType = (Stream_CodecType)info_CodecType;
pmodulestreaminfo->VideoInfo.PixFormat = (Stream_PixFormat)info_Stream_PixFormat;
pmodulestreaminfo->VideoInfo.Width = info_Width;
pmodulestreaminfo->VideoInfo.Height = info_Height;
pmodulestreaminfo->VideoCodecInfo.codec_format = (Stream_CodecFormat)info_codec_format;
pmodulestreaminfo->MuxInfo.mux_format = (Stream_MuxFormat)info_mux_format;

//查看需要在哪个info中填写pts dts
if(useinfotype == UseInfoType_Stream)
{
pmodulestreaminfo->VideoInfo.pts = info_pts;
pmodulestreaminfo->VideoInfo.dts = info_dts;
pmodulestreaminfo->VideoInfo.timebase_den = info_timebase_den;
pmodulestreaminfo->VideoInfo.timebase_num = info_timebase_num;
}
else if(useinfotype == UseInfoType_CodecDecode)
{
pmodulestreaminfo->VideoCodecInfo.pts = info_pts;
pmodulestreaminfo->VideoCodecInfo.dts = info_dts;
pmodulestreaminfo->VideoCodecInfo.timebase_den = info_timebase_den;
pmodulestreaminfo->VideoCodecInfo.timebase_num = info_timebase_num;
}
else if(useinfotype == UseInfoType_MuxDemux)
{
pmodulestreaminfo->MuxInfo.pts = info_pts;
pmodulestreaminfo->MuxInfo.dts = info_dts;
pmodulestreaminfo->MuxInfo.timebase_den = info_timebase_den;
pmodulestreaminfo->MuxInfo.timebase_num = info_timebase_num;
}
else
{
pmodulestreaminfo->VideoInfo.pts = info_pts;
pmodulestreaminfo->VideoInfo.dts = info_dts;
pmodulestreaminfo->VideoInfo.timebase_den = info_timebase_den;
pmodulestreaminfo->VideoInfo.timebase_num = info_timebase_num;
}
pmodulestreaminfo->BufLen = info_BufLen;
if(pmodulestreaminfo->Buf == NULL)
{
pmodulestreaminfo->Buf =(char *)calloc(pmodulestreaminfo->BufLen,sizeof(char));
}
memcpy(pmodulestreaminfo->Buf,info_Buf,info_ActualLen);
pmodulestreaminfo->ActualLen = info_ActualLen;
//如果用到的是StreamInfo_In
if(useModuleStreamInfo_In)
{
pmodule_info[count_info].ModuleStreamInfo_In = pmodulestreaminfo;
LOGD("useModuleStreamInfo_In");
}
//如果用到的是StreamInfo_Out
if(useModuleStreamInfo_Out)
{
pmodule_info[count_info].ModuleStreamInfo_Out = pmodulestreaminfo;
LOGD("useModuleStreamInfo_Out");
}
count_info ++;
}

//释放
env->ReleaseByteArrayElements(barr_Buf, info_Buf, 0);//释放资源
env->DeleteLocalRef(jkeyobject);
env->DeleteLocalRef(jintclass);
env->DeleteLocalRef(jvalueobject);
env->DeleteLocalRef(jvalueclass);
}
*Length = needlength;
*module_info = pmodule_info;

//释放
env->DeleteLocalRef(jmapclass);
env->DeleteLocalRef(jsetkey);
env->DeleteLocalRef(jsetclass);
env->DeleteLocalRef(jobjArray);
return 1;
}

//将本模块的c++用的Module_Info转化为参数jobj_Current(Hashmap)
static int Module_Info2Jobject(JNIEnv * env, jobject thiz,Module_Info * module_info,int Length,jobject jobj,
UseInfoType useinfotype)
{
int ret = 0;

//查看传进来的object是否是空
if (module_info == NULL)
{
LOGD("Module_Info2Jobject module_info == NULL");
return 1;
}

//生成object(hashmap)
jclass class_hashmap = env->GetObjectClass(jobj);
jmethodID HashMap_put_id = env->GetMethodID(class_hashmap, "put","(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");

//查找要生成的vlaue类class
jclass class_LvsAndroidInfo = env->FindClass("com/android/lvs/lvsandroidinfo/LvsAndroidInfo");

if (class_LvsAndroidInfo == NULL)
{
LOGD("not found class_LvsAndroidInfo");
return -1;
}
else
{
LOGD("sucess found class_LvsAndroidInfo");
}
jclass class_LvsAndroidInfo_key = env->FindClass("java/lang/Integer");
if (class_LvsAndroidInfo_key == NULL)
{
LOGD("not found class_LvsAndroidInfo_key");
return -1;
}
else
{
LOGD("sucess found class_LvsAndroidInfo_key");
}

//生成map内容
for( int i=0; i < Length; i++)
{
int stream_id = ((Module_HeaderInfo_FFmpeg_Video_Codec *)(module_info[i].ModuleHeaderInfo.HeaderInfo))->stream_id;
LOGD("Module_HeaderInfo_FFmpeg_Video_Codec stream_id : %d",stream_id);

//key
LOGD("key");
jmethodID LvsAndroidInfo_key_id = env->GetMethodID(class_LvsAndroidInfo_key, "<init>","(I)V");                      //new这个key的id
jobject LvsAndroidInfo_keyobject = env->NewObject(class_LvsAndroidInfo_key,LvsAndroidInfo_key_id,stream_id);          //new一个object

//value
LOGD("value");
jmethodID LvsAndroidInfo_id = env->GetMethodID(class_LvsAndroidInfo, "<init>","()V");          //new这个class的id
jobject LvsAndroidInfoobject = env->NewObject(class_LvsAndroidInfo,LvsAndroidInfo_id, "");       //new一个object

//stream_id
jmethodID setstream_id_id = env->GetMethodID(class_LvsAndroidInfo, "setstream_id","(I)V");
if(setstream_id_id == NULL)
{
LOGD("error :setstream_id_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setstream_id_id,stream_id);

//Is_ToNext_Module
jmethodID setIs_ToNext_Module_id = env->GetMethodID(class_LvsAndroidInfo, "setIs_ToNext_Module","(I)V");
if(setIs_ToNext_Module_id == NULL)
{
LOGD("error :setIs_ToNext_Module_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setIs_ToNext_Module_id,module_info[i].Is_ToNext_Module);

//CodecType
jmethodID setCodecType_id = env->GetMethodID(class_LvsAndroidInfo, "setCodecType","(I)V");
if(setCodecType_id == NULL)
{
LOGD("error :setCodecType_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setCodecType_id,(int)module_info[i].ModuleStreamInfo_Out->CodecType);

//pts
jmethodID setpts_id = env->GetMethodID(class_LvsAndroidInfo, "setpts","(J)V");
if(setpts_id == NULL)
{
LOGD("error :setpts_id");
return NULL;
}

//dts
jmethodID setdts_id = env->GetMethodID(class_LvsAndroidInfo, "setdts","(J)V");
if(setdts_id == NULL)
{
LOGD("error :setdts_id");
return NULL;
}

//timebase_num
jmethodID settimebase_num_id = env->GetMethodID(class_LvsAndroidInfo, "settimebase_num","(I)V");
if(settimebase_num_id == NULL)
{
LOGD("error :settimebase_num_id");
return NULL;
}

//timebase_den
jmethodID settimebase_den_id = env->GetMethodID(class_LvsAndroidInfo, "settimebase_den","(I)V");
if(settimebase_den_id == NULL)
{
LOGD("error :settimebase_den_id");
return NULL;
}

//查看需要在哪个info中填写pts dts
if(useinfotype == UseInfoType_Stream)
{
env->CallVoidMethod(LvsAndroidInfoobject,setpts_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.pts);
env->CallVoidMethod(LvsAndroidInfoobject,setdts_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.dts);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_num_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.timebase_num);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_den_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.timebase_den);
}
else if(useinfotype == UseInfoType_CodecDecode)
{
env->CallVoidMethod(LvsAndroidInfoobject,setpts_id,module_info[i].ModuleStreamInfo_Out->VideoCodecInfo.pts);
env->CallVoidMethod(LvsAndroidInfoobject,setdts_id,module_info[i].ModuleStreamInfo_Out->VideoCodecInfo.dts);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_num_id,module_info[i].ModuleStreamInfo_Out->VideoCodecInfo.timebase_num);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_den_id,module_info[i].ModuleStreamInfo_Out->VideoCodecInfo.timebase_den);
}
else if(useinfotype == UseInfoType_MuxDemux)
{
env->CallVoidMethod(LvsAndroidInfoobject,setpts_id,module_info[i].ModuleStreamInfo_Out->MuxInfo.pts);
env->CallVoidMethod(LvsAndroidInfoobject,setdts_id,module_info[i].ModuleStreamInfo_Out->MuxInfo.dts);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_num_id,module_info[i].ModuleStreamInfo_Out->MuxInfo.timebase_num);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_den_id,module_info[i].ModuleStreamInfo_Out->MuxInfo.timebase_den);
}
else
{
env->CallVoidMethod(LvsAndroidInfoobject,setpts_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.pts);
env->CallVoidMethod(LvsAndroidInfoobject,setdts_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.dts);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_num_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.timebase_num);
env->CallVoidMethod(LvsAndroidInfoobject,settimebase_den_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.timebase_den);
}

//BufLen
jmethodID setBufLen_id = env->GetMethodID(class_LvsAndroidInfo, "setBufLen","(J)V");
if(setpts_id == NULL)
{
LOGD("error :setBufLen_id");
return NULL;
}
//这里一定故要用ModuleStreamInfo_In的buf长度，上层传过来的会比本层输出的buf大
env->CallVoidMethod(LvsAndroidInfoobject,setBufLen_id,module_info[i].ModuleStreamInfo_In->BufLen);

//ActualLen
jmethodID setActualLen_id = env->GetMethodID(class_LvsAndroidInfo, "setActualLen","(J)V");
if(setActualLen_id == NULL)
{
LOGD("error :setActualLen_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setActualLen_id,module_info[i].ModuleStreamInfo_Out->ActualLen);

//Buf
jmethodID setBuf_id = env->GetMethodID(class_LvsAndroidInfo, "setBuf","([B)V");
if(setBuf_id == NULL)
{
LOGD("error :setBuf_id");
return NULL;
}
jbyteArray bufbyteArray = env->NewByteArray(module_info[i].ModuleStreamInfo_Out->ActualLen);
env->SetByteArrayRegion(bufbyteArray,0,module_info[i].ModuleStreamInfo_Out->ActualLen,(const jbyte *)module_info[i].ModuleStreamInfo_Out->Buf);
env->CallVoidMethod(LvsAndroidInfoobject,setBuf_id,bufbyteArray);

//Stream_PixFormat
jmethodID setStream_PixFormat_id = env->GetMethodID(class_LvsAndroidInfo, "setStream_PixFormat","(I)V");
if(setStream_PixFormat_id == NULL)
{
LOGD("error :setStream_PixFormat_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setStream_PixFormat_id,(int)module_info[i].ModuleStreamInfo_Out->VideoInfo.PixFormat);

//Width
jmethodID setWidth_id = env->GetMethodID(class_LvsAndroidInfo, "setWidth","(I)V");
if(setWidth_id == NULL)
{
LOGD("error :setWidth_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setWidth_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.Width);

//Height
jmethodID setHeight_id = env->GetMethodID(class_LvsAndroidInfo, "setHeight","(I)V");
if(setHeight_id == NULL)
{
LOGD("error :setHeight_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setHeight_id,module_info[i].ModuleStreamInfo_Out->VideoInfo.Height);

//codec_format
jmethodID setcodec_format_id = env->GetMethodID(class_LvsAndroidInfo, "setcodec_format","(I)V");
if(setcodec_format_id == NULL)
{
LOGD("error :setcodec_format_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setcodec_format_id,(int)(module_info[i].ModuleStreamInfo_Out->VideoCodecInfo.codec_format));

//mux_format
jmethodID setmux_format_id = env->GetMethodID(class_LvsAndroidInfo, "setmux_format","(I)V");
if(setmux_format_id == NULL)
{
LOGD("error :setmux_format_id");
return NULL;
}
env->CallVoidMethod(LvsAndroidInfoobject,setmux_format_id,(int)module_info[i].ModuleStreamInfo_Out->MuxInfo.mux_format);

//调用hashmap put方法
env->CallObjectMethod(jobj,HashMap_put_id,LvsAndroidInfo_keyobject,LvsAndroidInfoobject);

//释放
env->DeleteLocalRef(LvsAndroidInfo_keyobject);
env->DeleteLocalRef(LvsAndroidInfoobject);
env->DeleteLocalRef(bufbyteArray);
}
//释放
env->DeleteLocalRef(class_hashmap);
env->DeleteLocalRef(class_LvsAndroidInfo);
env->DeleteLocalRef(class_LvsAndroidInfo_key);
return 1;
}