jNI callback

#include <stdio.h>
#include <jni.h>
#include "tdnmanager.h"
#define LOG_TAG "Network"
#include "log.h"
#include "NetworkCallback.h"
#include <stdlib.h>

static const char* const kClassNameNetwork =
        "com/apical/aiproforcloud/networklibrary/LibNetwork";
static const char* const kClassNameNetworkCallback =
        "com/apical/aiproforcloud/networklibrary/Callback";    
static const char* const kClassNameDeviceStatus =
        "com/apical/aiproforcloud/networklibrary/DeviceStatusInfo";    
static const char* const kClassNameRemonitoringFileInfo =
        "com/apical/aiproforcloud/networklibrary/RemonitoringFileInfo";
static const char* const kClassNameAlarmRecord =
        "com/apical/aiproforcloud/networklibrary/AlarmRecord";        
static const char* const kClassNameOutOfMemoryException =
        "java/lang/OutOfMemoryError";
static const char* const kClassNameOutOfNullPointerException =
        "java/lang/NullPointerException";
static const char* const devicestatusinfoexceptiondescript = "DeviceStatusInfo -- Get Info Failue";
static const char* const remonitoringfileinfoexceptiondescript = "RemonitoringFileInfo -- Get Info Failue";
static const char* const alarmrecordexceptiondescript = "AlarmRecord -- Get Info Failue";
    static JavaVM* myVm = NULL;
    static jobject Network_Callback = NULL;
    struct fields_t {
    jmethodID callStartNetwork;
    jmethodID callCloseNetWork;
    jmethodID callbackCancelAlarmInfo;
    jmethodID callbackGetDeviceStatus;
    jmethodID callbackVehicleStatus;
    jmethodID callbackStartRealMonitorVideoStream;
    jmethodID callbackStopRealMonitorVideoStream;
    jmethodID callbackDownloadVideo;
    jmethodID callbackException;
    jmethodID callbackAlarmInfo;
    jmethodID callbackFailue;
    jmethodID callbackOvertime;
    jmethodID callbackUploadAlarmVideoCompletely;
    jmethodID callbackAlarmHistory;
    jmethodID callbackUploadFile;
    jmethodID callbackSnapShot;
    jmethodID callbackOpenGpsInfo;
    jmethodID callbackCloseGpsInfo;
    jmethodID callbackDrivingFile;
    }fields;
    jclass jclassDeviceStatusInfo;
    struct devicestatusinfofields_t{
        jfieldID jfieldIDstrDevId;
        jfieldID jfieldIDnState;
        jmethodID jmethodIDinit;
    }devicestatusinfofields;
    jboolean jbdevicestatusinfostate = JNI_FALSE; // 纪录java层DeviceStatusInfo相关对象是否正常获取
    
    jclass jclassRemonitoringFileInfo;
    struct remonitoringfileinfofields_t{
        jfieldID jfieldIDstrFileName;
        jfieldID jfieldIDstrFileTime;
        jfieldID jfieldIDnCanPlay;
        jmethodID jmethodIDinit;
    }remonitoringfileinfofields;
    jboolean jbremonitoringfileinfostate = JNI_FALSE; // 纪录java层RemonitoringFileInfo相关对象是否正常获取
    
    jclass jclassAlarmRecord;
    struct alarmrecordfields_t{
        jfieldID jfieldIDstrDevId;
        jfieldID jfieldIDsalarmType;
        jfieldID jfieldIDstrAlarmTime;
        jfieldID jfieldIDstrFileName;
        jfieldID jfieldIDFileSize;
        jfieldID jfieldIDPlayUrl;
        jmethodID jmethodIDinit;
    }alarmrecordfields;
    jboolean jbalarmrecordstate = JNI_FALSE; // 纪录java层RemonitoringFileInfo相关对象是否正常获取
    
typedef enum _GET_JNIENV_STATUS{
    GET_FAIL = 0,
    GET_SUCCES_NOATTACH,
    GET_SUCCES_ATTCH,
}Get_JNIEnv_Status;

// 获取JNIInv
static Get_JNIEnv_Status getJNIEnv(JNIEnv* &env)
{
    Get_JNIEnv_Status GetStatus = GET_FAIL;  
    int status = myVm->GetEnv((void **) &env, JNI_VERSION_1_4);  
 
    if(status < 0) {
        status = myVm->AttachCurrentThread(&env, NULL);  
        if(status < 0) {  
            return GetStatus;  
        }  
        GetStatus = GET_SUCCES_ATTCH;  
    }
    else
    {
        GetStatus = GET_SUCCES_NOATTACH;
    }
    return GetStatus;
}

// 增加异常处理的回调
jvalue JNU_CallMethodByName(JNIEnv *env,
     jobject obj,
     jmethodID mid,
     const char returnType, va_list args)
{
     //va_list args;
     jclass clazz;
     jvalue result;
     if (env->EnsureLocalCapacity(2) == JNI_OK) {
        clazz = env->GetObjectClass(obj);
        if (mid) {
            /* skip over argument types to find out the
            return type */
            //va_start(args, returnType);
            //int t = va_arg(args, int);
            //LOGE("JNU_CallMethodByName -2 t = %d\n", t);
            //va_end(args);
            //va_start(args, returnType);
            switch (returnType) {
                case 'V':
                    env->CallVoidMethodV(obj, mid, args);
                    break;
                case '[':
                case 'L':
                    result.l = env->CallObjectMethodV(obj, mid, args);
                    break;
                case 'Z':
                    result.z = env->CallBooleanMethodV(obj, mid, args);
                    break;
                case 'B':
                    result.b = env->CallByteMethodV(obj, mid, args);
                    break;
                case 'C':
                    result.c = env->CallCharMethodV(obj, mid, args);
                    break;
                case 'S':
                    result.s = env->CallShortMethodV(obj, mid, args);
                    break;
                case 'I':
                    result.i = env->CallIntMethodV(obj, mid, args);
                    break;
                case 'J':
                    result.j = env->CallLongMethodV(obj, mid, args);
                break;
                case 'F':
                    result.f = env->CallFloatMethodV(obj, mid, args);
                    break;
                case 'D':
                    result.d = env->CallDoubleMethodV(obj, mid, args);
                    break;
                default:
                    env->FatalError("illegal descriptor");
            }
            va_end(args);
        }
        env->DeleteLocalRef(clazz);
    }
    if(env->ExceptionCheck())
    {
        env->ExceptionClear();
    }
    return result;
}

// 返回值为空的回调
jvalue JNU_CallVoidMethodByName(JNIEnv *env,
     jobject obj,
     jmethodID mid, ...)
{
    jvalue value;
    va_list args;
    va_start(args, mid);
    value = JNU_CallMethodByName(env, obj, mid, 'V', args);
    va_end(args);
    return value;
}

// 返回异常
void JNU_ThrowByName(JNIEnv* env, const char* name, const char *msg)
{
    jclass cls = env->FindClass(name);
    if(cls != NULL)
    {
        env->ThrowNew(cls, msg);
        env->DeleteLocalRef(cls);
    }
}

static void CallbackStartNetwork()
{
    LOGE("150331 - CallbackStartNetwork - 1");
    if (Network_Callback == NULL)
        return;
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    if(GetStatus == GET_FAIL)
    {
        return ;
    }
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callStartNetwork);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackCloseNetwork()
{
    LOGE("150331 - CallbackCloseNetwork - 1");
    if (Network_Callback == NULL)
        return;
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    if(GetStatus == GET_FAIL)
    {
        return ;
    }
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callCloseNetWork);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }    
}


static void CallbackCancelAlarmInfo(char* pszDevID, char* pszGuid)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    jstring jstrGuid = env->NewStringUTF(pszGuid);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackCancelAlarmInfo, jstrDevID, jstrGuid);
    env->DeleteLocalRef(jstrDevID);
    env->DeleteLocalRef(jstrGuid);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackVehicleStatus(char* pszDevID, char* pszGPSInfo)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    jstring jstrGPSInfo = env->NewStringUTF(pszGPSInfo);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackVehicleStatus, jstrDevID, jstrGPSInfo);
    env->DeleteLocalRef(jstrDevID);
    env->DeleteLocalRef(jstrGPSInfo);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}


static void CallbackGetDeviceStatus(Device_StatusInfo deviceStatusArray[], int length)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    if(Network_Callback == NULL || !jbdevicestatusinfostate)
    {
        return ;
    }
    else
    {
        jobjectArray jdeviceStatusInfoArray= env->NewObjectArray(length, jclassDeviceStatusInfo, 0);
        for(int i = 0; i < length; i++)
        {
            jobject deviceStatusInfoObject= env->NewObject(jclassDeviceStatusInfo, devicestatusinfofields.jmethodIDinit);
            jstring jstr = env->NewStringUTF(deviceStatusArray[i].pszDevID);
            env->SetObjectField(deviceStatusInfoObject, devicestatusinfofields.jfieldIDstrDevId, jstr);
            env->SetIntField(deviceStatusInfoObject, devicestatusinfofields.jfieldIDnState, deviceStatusArray[i].deviceStatus);
            env->SetObjectArrayElement(jdeviceStatusInfoArray, i, deviceStatusInfoObject);
            env->DeleteLocalRef(deviceStatusInfoObject);
        }
        //env->CallVoidMethod (Network_Callback, fields.callbackGetDeviceStatus, nState, jdeviceStatusInfoArray, length);
        JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackGetDeviceStatus, jdeviceStatusInfoArray, length);
        env->DeleteLocalRef(jdeviceStatusInfoArray);
    }
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackStartRealMonitorVideoStream( char* pszDevID, char* pszPlayurl)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    jstring jstrPlayurl = env->NewStringUTF(pszPlayurl);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackStartRealMonitorVideoStream, jstrDevID, jstrPlayurl);
    env->DeleteLocalRef(jstrDevID);
    env->DeleteLocalRef(jstrPlayurl);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackStopRealMonitorVideoStream(char* pszDevID)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackStopRealMonitorVideoStream, jstrDevID);
    env->DeleteLocalRef(jstrDevID);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackDownloadVideo(char* pszDevID, char* pszFileName, int nProgress,char* ResourceID,char* lon,char* lat)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    jstring jstrFileName = env->NewStringUTF(pszFileName);
    jstring jstrResourceID = env->NewStringUTF(ResourceID);
    jstring jstrlon = env->NewStringUTF(lon);
    jstring jstrlat= env->NewStringUTF(lat);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackDownloadVideo, jstrDevID, jstrFileName, nProgress,jstrResourceID,jstrlon,jstrlat);
    env->DeleteLocalRef(jstrDevID);
    env->DeleteLocalRef(jstrFileName);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackException(int exceptionType, int exceptionReason, char* pszParam1)
{
    LOGE("150331 - CallbackException - 1");
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrParam1 = env->NewStringUTF(pszParam1);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackException, exceptionType, exceptionReason, jstrParam1);
    env->DeleteLocalRef(jstrParam1);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackAlarmInfo(char* pszDevID, char* pszGuid, short AlarmType, char* pszAlarmTime, char* pszfileSize, char* pszfileName)
{
    LOGE("14112820 - CallbackAlarmInfo - 1");
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    jstring jstrGuid = env->NewStringUTF(pszGuid);
    jstring jstrAlarmTime = env->NewStringUTF(pszAlarmTime);
    jstring jstrfileSize = env->NewStringUTF(pszfileSize);
    jstring jstrfileName = env->NewStringUTF(pszfileName);
    LOGE("14112820 - CallbackAlarmInfo - 2");
    //env->CallVoidMethod (Network_Callback, fields.callbackAlarmInfo, jstrDevID, jstrGuid, AlarmType, jstrAlarmTime);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackAlarmInfo, jstrDevID, jstrGuid, AlarmType, jstrAlarmTime, jstrfileSize, jstrfileName);
    env->DeleteLocalRef(jstrDevID);
    env->DeleteLocalRef(jstrGuid);
    env->DeleteLocalRef(jstrAlarmTime);
    env->DeleteLocalRef(jstrfileSize);
    env->DeleteLocalRef(jstrfileName);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
    LOGE("14112820 - CallbackAlarmInfo - 3");
}

static void CallbackFailue(FunctionSymbol functionSymbol, int reason, char* param1, char* param2)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrparam1 = env->NewStringUTF(param1);
    jstring jstrparam2 = env->NewStringUTF(param2);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackFailue, functionSymbol, reason, jstrparam1, jstrparam2);
    env->DeleteLocalRef(jstrparam1);
    env->DeleteLocalRef(jstrparam2);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackOvertime(FunctionSymbol functionSymbol, int overtimeReason, char* pszParam1, char* pszParam2)
{
    LOGE("150331 - CallbackOvertime - 1");
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrparam1 = env->NewStringUTF(pszParam1);
    jstring jstrparam2 = env->NewStringUTF(pszParam2);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackOvertime, functionSymbol, overtimeReason, jstrparam1, jstrparam2);
    env->DeleteLocalRef(jstrparam1);
    env->DeleteLocalRef(jstrparam2);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackUploadAlarmVideoCompletely(char* pszDevID, char* pszGuid, char* pszPlayurl)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    jstring jstrGuid = env->NewStringUTF(pszGuid);
    jstring jstrPlayurl = env->NewStringUTF(pszPlayurl);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackUploadAlarmVideoCompletely, jstrDevID, jstrGuid, jstrPlayurl);
    env->DeleteLocalRef(jstrDevID);
    env->DeleteLocalRef(jstrGuid);
    env->DeleteLocalRef(jstrPlayurl);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackAlarmHistory(Alarm_Record alarmRecord[], int length, int whichPage)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    if(Network_Callback == NULL || !jbalarmrecordstate)
    {
        return ;
    }
    else
    {
        jobjectArray jAlarmRecordArray= env->NewObjectArray(length, jclassAlarmRecord, 0);
        for(int i = 0; i < length; i++)
        {
            jobject alarmRecordObject= env->NewObject(jclassAlarmRecord, alarmrecordfields.jmethodIDinit);
            jstring jstrDevID = env->NewStringUTF(alarmRecord[i].pszDevID);
            jstring jstrAlarmTime = env->NewStringUTF(alarmRecord[i].pszAlarmTime);
            jstring jstrFileName = env->NewStringUTF(alarmRecord[i].pszFileName);
            jstring jstrFileSize = env->NewStringUTF(alarmRecord[i].pszFileSize);
            jstring jstrPlayUrl = env->NewStringUTF(alarmRecord[i].pszPlayUrl);
            env->SetObjectField(alarmRecordObject, alarmrecordfields.jfieldIDstrDevId, jstrDevID);
            env->SetShortField(alarmRecordObject, alarmrecordfields.jfieldIDsalarmType, alarmRecord[i].alarmType);
            env->SetObjectField(alarmRecordObject, alarmrecordfields.jfieldIDstrAlarmTime, jstrAlarmTime);
            env->SetObjectField(alarmRecordObject, alarmrecordfields.jfieldIDstrFileName, jstrFileName);
            env->SetObjectField(alarmRecordObject, alarmrecordfields.jfieldIDFileSize, jstrFileSize);
            env->SetObjectField(alarmRecordObject, alarmrecordfields.jfieldIDPlayUrl, jstrPlayUrl);
            env->SetObjectArrayElement(jAlarmRecordArray, i, alarmRecordObject);
            env->DeleteLocalRef(alarmRecordObject);
        }
        JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackAlarmHistory, jAlarmRecordArray, length, whichPage);
        env->DeleteLocalRef(jAlarmRecordArray);
    }
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackUploadFile(char* fileName, int progress)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrfileName = env->NewStringUTF(fileName);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackUploadFile, jstrfileName, progress);
    env->DeleteLocalRef(jstrfileName);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackOpenGpsInfo(char* pszDevID)
{
    LOGE("150401 -- CallbackOpenGpsInfo");
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackOpenGpsInfo, jstrDevID);
    env->DeleteLocalRef(jstrDevID);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackSnapShot(char* pszDevID)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackSnapShot, jstrDevID);
    env->DeleteLocalRef(jstrDevID);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackCloseGpsInfo(char* pszDevID)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackCloseGpsInfo, jstrDevID);
    env->DeleteLocalRef(jstrDevID);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static void CallbackDrivingFile(char* pszDevID)
{
    JNIEnv *env;
    Get_JNIEnv_Status GetStatus = getJNIEnv(env);
    jstring jstrDevID = env->NewStringUTF(pszDevID);
    JNU_CallVoidMethodByName(env, Network_Callback, fields.callbackDrivingFile, jstrDevID);
    env->DeleteLocalRef(jstrDevID);
    if(GetStatus == GET_SUCCES_ATTCH)
    {
        myVm->DetachCurrentThread();
    }
}

static int native_init(JNIEnv *env, jclass clazz)
{
    GetNetworkCallback()->m_CallbackStartNetwork = CallbackStartNetwork;
    GetNetworkCallback()->m_CallbackCloseNetwork = CallbackCloseNetwork;
    GetNetworkCallback()->m_CallbackCancelAlarmInfo = CallbackCancelAlarmInfo;
    GetNetworkCallback()->m_CallbackGetDeviceStatus = CallbackGetDeviceStatus;
    GetNetworkCallback()->m_CallbackGetVehicleStatus = CallbackVehicleStatus;
    GetNetworkCallback()->m_CallbackStartRealMonitorVideoStream = CallbackStartRealMonitorVideoStream;
    GetNetworkCallback()->m_CallbackStopRealMonitorVideoStream = CallbackStopRealMonitorVideoStream;
    GetNetworkCallback()->m_CallbackDownloadVideo = CallbackDownloadVideo;
    GetNetworkCallback()->m_CallbackException = CallbackException;
    GetNetworkCallback()->m_CallbackAlarmInfo = CallbackAlarmInfo;
    GetNetworkCallback()->m_CallbackFailue = CallbackFailue;
    GetNetworkCallback()->m_CallbackOvertime = CallbackOvertime;
    GetNetworkCallback()->m_CallbackUploadAlarmVideoCompletely = CallbackUploadAlarmVideoCompletely;
    GetNetworkCallback()->m_CallbackAlarmHistory = CallbackAlarmHistory;
    GetNetworkCallback()->m_CallbackUploadPicture = CallbackUploadFile;
    GetNetworkCallback()->m_CallbackOpenGpsInfo = CallbackOpenGpsInfo;
    GetNetworkCallback()->m_CallbackSnapShot = CallbackSnapShot;
    GetNetworkCallback()->m_CallbackCloseGpsInfo = CallbackCloseGpsInfo;
    GetNetworkCallback()->m_CallbackDrivingFile = CallbackDrivingFile;
}

static void CallStartNetwork(JNIEnv *env, jobject object, jstring strClientIDNO, jchar cTerminalFlag, jstring strServerIP, jshort usPort)
{    
    LOGE("-------jni StartNetwork-----");
    const char* p_szClientIDNO = env->GetStringUTFChars(strClientIDNO, 0);
    if(p_szClientIDNO == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    const char* p_szServerIP = env->GetStringUTFChars(strServerIP, 0);
    if(p_szServerIP == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        env->ReleaseStringUTFChars(strClientIDNO, p_szClientIDNO);
        return ;
    }
    StartNetwork((char*)p_szClientIDNO, cTerminalFlag, (char*)p_szServerIP, usPort);
    env->ReleaseStringUTFChars(strClientIDNO, p_szClientIDNO);
    env->ReleaseStringUTFChars(strServerIP, p_szServerIP);
}

static void CallCloseNetwork(JNIEnv *env, jobject object)
{
    LOGE("14112915 - CallCloseNetwork");
    CloseNetwork();
}

static void CallCancelAlarmInfo(JNIEnv *env, jobject object, jstring strDevID, jstring strGuid)
{
    LOGE("14112915 - CallCancelAlarmInfo");
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    const char* p_szGuid = env->GetStringUTFChars(strGuid, 0);
    if(p_szGuid == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        env->ReleaseStringUTFChars(strDevID, p_szDevID);
        return ;
    }
    CancelAlarmInfo((char*)p_szDevID, (char*)p_szGuid);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
    env->ReleaseStringUTFChars(strGuid, p_szGuid);
}

static void CallGetDeviceStatus(JNIEnv *env, jobject object)
{
    LOGE("14112915 - CallGetDeviceStatus");
    GetDeviceStatus();
}

static void CallGetVehicleStatus(JNIEnv *env, jobject object, jstring strDevID)
{
    LOGE("14112915 - CallGetVehicleStatus");
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    LOGE("CallGetVehicleStatus 1 -- p_szDevID = %s", p_szDevID);
    GetVehicleStatus((char*)p_szDevID);
    LOGE("CallGetVehicleStatus 2 -- p_szDevID = %s", p_szDevID);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
}

static void CallRealtimeMonitorVideoStream(JNIEnv *env, jobject object, jstring strDevID, jint startOrStop)
{
    LOGE("14112915 - CallRealtimeMonitorVideoStream");
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    LOGE("CallRealtimeMonitorVideoStream 1 -- p_szDevID = %s", p_szDevID);
    RealtimeMonitorVideoStream((char*)p_szDevID, startOrStop);
    LOGE("CallRealtimeMonitorVideoStream 2 -- p_szDevID = %s", p_szDevID);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
}

static void CallGetAlarmRecord(JNIEnv *env, jobject object, jstring strDevID, jint nYear,jint nMonth,jint nDay,jint nHour,jint nMin,jint nSecond,jint nEndTime,jint nRecType,jint nChannel)
{
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    GetAlarmRecord((char*)p_szDevID, nYear, nMonth, nDay, nHour, nMin, nSecond, nEndTime, nRecType, nChannel);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
}

static void CallDownloadVideo(JNIEnv *env, jobject object, jstring strDevID,jint nOffset,jint nStartOffset,jint nEndOffset,jstring strfilename)
{
    LOGE("14112915 - CallDownloadVideo");
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    const char* p_szfilename = env->GetStringUTFChars(strfilename, 0);
    if(p_szfilename == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        env->ReleaseStringUTFChars(strDevID, p_szDevID);
        return ;
    }
    DownloadVideo((char*)p_szDevID, nOffset, nStartOffset, nEndOffset, (char*)p_szfilename);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
    env->ReleaseStringUTFChars(strfilename, p_szfilename);
}

static void CallOpenGPSInfo(JNIEnv *env, jobject object, jstring strDevID)
{
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    OpenGPSInfo((char*)p_szDevID);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
}

static void CallCloseGPSInfo(JNIEnv *env, jobject object, jstring strDevID)
{
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    CloseGPSInfo((char*)p_szDevID);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
}

static void CallSnapShotFile(JNIEnv *env, jobject object, jstring strDevID)
{
    const char* p_szDevID = env->GetStringUTFChars(strDevID, 0);
    if(p_szDevID == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    SnapShotFile((char*)p_szDevID);
    env->ReleaseStringUTFChars(strDevID, p_szDevID);
}

static void CallUploadFile(JNIEnv *env, jobject object, jint nOffset,jint nStartOffset,jint nEndOffset,jstring filename,jstring longitude,jstring latitude,jstring time)
{
    const char* p_szfilename = env->GetStringUTFChars(filename, 0);
    if(p_szfilename == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    char* p_szlongitude;
    if(longitude != NULL)
    {
        p_szlongitude = (char*)env->GetStringUTFChars(longitude, 0);
        if(p_szlongitude == NULL)
        {
            jthrowable jthrowableException =  env->ExceptionOccurred();
            env->Throw(jthrowableException);
            return ;
        }
    }
    else
    {
        p_szlongitude = NULL;
    }
    char* p_szlatitude;
    if(latitude != NULL)
    {
        p_szlatitude = (char*)env->GetStringUTFChars(latitude, 0);
        if(p_szlatitude == NULL)
        {
            jthrowable jthrowableException =  env->ExceptionOccurred();
            env->Throw(jthrowableException);
            return ;
        }
    }
    else
    {
        p_szlatitude = NULL;
    }
    const char* p_sztime = env->GetStringUTFChars(time, 0);
    if(p_sztime == NULL)
    {
        jthrowable jthrowableException =  env->ExceptionOccurred();
        env->Throw(jthrowableException);
        return ;
    }
    UploadFile(nOffset, nStartOffset, nEndOffset, (char*)p_szfilename, (char*)p_szlongitude, (char*)p_szlatitude, (char*)p_sztime);
    env->ReleaseStringUTFChars(filename, p_szfilename);
    if(p_szlongitude != NULL)
    {
        env->ReleaseStringUTFChars(longitude, p_szlongitude);
    }
    if(p_szlongitude != NULL)
    {
        env->ReleaseStringUTFChars(latitude, p_szlatitude);
    }
    env->ReleaseStringUTFChars(time, p_sztime);
}

static void CallsetCallbackObject(JNIEnv *env, jobject thiz, jobject callback)
{
    Network_Callback = env->NewGlobalRef(callback);
    jclass cls = env->GetObjectClass (Network_Callback);
    if(cls != NULL)
    {
        fields.callStartNetwork = env->GetMethodID (cls, "callStartNetwork", "()V");
        fields.callCloseNetWork = env->GetMethodID (cls, "callCloseNetwork", "()V");
        fields.callbackCancelAlarmInfo = env->GetMethodID (cls, "callbackCancelAlarmInfo", "(Ljava/lang/String;Ljava/lang/String;)V");
        fields.callbackGetDeviceStatus = env->GetMethodID (cls, "callbackGetDeviceStatus", "([Lcom/apical/aiproforcloud/networklibrary/DeviceStatusInfo;I)V");
        fields.callbackVehicleStatus = env->GetMethodID (cls, "callbackVehicleStatus", "(Ljava/lang/String;Ljava/lang/String;)V");
        fields.callbackStartRealMonitorVideoStream = env->GetMethodID (cls, "callbackStartRealMonitorVideoStream", "(Ljava/lang/String;Ljava/lang/String;)V");
        fields.callbackStopRealMonitorVideoStream = env->GetMethodID (cls, "callbackStopRealMonitorVideoStream", "(Ljava/lang/String;)V");
        fields.callbackDownloadVideo = env->GetMethodID (cls, "callbackDownloadVideo", "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
        fields.callbackException = env->GetMethodID (cls, "callbackException", "(IILjava/lang/String;)V");
        fields.callbackAlarmInfo = env->GetMethodID (cls, "callbackAlarmInfo", "(Ljava/lang/String;Ljava/lang/String;SLjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
        fields.callbackFailue = env->GetMethodID(cls, "callbackFailue", "(IILjava/lang/String;Ljava/lang/String;)V");
        fields.callbackOvertime = env->GetMethodID(cls, "callbackOvertime", "(IILjava/lang/String;Ljava/lang/String;)V");
        fields.callbackAlarmHistory = env->GetMethodID(cls, "callbackAlarmHistory", "([Lcom/apical/aiproforcloud/networklibrary/AlarmRecord;II)V");
        fields.callbackUploadFile = env->GetMethodID(cls, "callbackUploadFile", "(Ljava/lang/String;I)V");
        fields.callbackOpenGpsInfo = env->GetMethodID(cls, "callbackOpenGpsInfo", "(Ljava/lang/String;)V");
        fields.callbackSnapShot = env->GetMethodID(cls, "callbackSnapShot", "(Ljava/lang/String;)V");
        fields.callbackCloseGpsInfo = env->GetMethodID(cls, "callbackCloseGpsInfo", "(Ljava/lang/String;)V");
        fields.callbackDrivingFile = env->GetMethodID(cls, "callbackDrivingFile", "(Ljava/lang/String;)V");
        fields.callbackUploadAlarmVideoCompletely = env->GetMethodID(cls, "callbackUploadAlarmVideoCompletely", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
    }
    jclassDeviceStatusInfo = (jclass)env->NewGlobalRef(env->FindClass(kClassNameDeviceStatus));
    if(jclassDeviceStatusInfo != NULL)
    {
        devicestatusinfofields.jfieldIDstrDevId = env->GetFieldID(jclassDeviceStatusInfo,"strDevID","Ljava/lang/String;");
        devicestatusinfofields.jfieldIDnState = env->GetFieldID(jclassDeviceStatusInfo,"nState","I");
        devicestatusinfofields.jmethodIDinit = env->GetMethodID(jclassDeviceStatusInfo, "<init>", "()V");
    }
    if(jclassDeviceStatusInfo != NULL && devicestatusinfofields.jfieldIDstrDevId != NULL
    && devicestatusinfofields.jfieldIDnState != NULL && devicestatusinfofields.jmethodIDinit != NULL)
    {
        jbdevicestatusinfostate = JNI_TRUE;
    }
    else
    {
        JNU_ThrowByName(env, kClassNameOutOfNullPointerException, devicestatusinfoexceptiondescript);
    }
/*    jclassRemonitoringFileInfo = (jclass)env->NewGlobalRef(env->FindClass(kClassNameRemonitoringFileInfo));
    if(jclassRemonitoringFileInfo != NULL)
    {
        remonitoringfileinfofields.jfieldIDstrFileName = env->GetFieldID(jclassRemonitoringFileInfo,"strFileName","Ljava/lang/String;");
        remonitoringfileinfofields.jfieldIDstrFileTime = env->GetFieldID(jclassRemonitoringFileInfo,"strFileTime","Ljava/lang/String;");
        remonitoringfileinfofields.jfieldIDnCanPlay = env->GetFieldID(jclassRemonitoringFileInfo,"nCanPlay","I");
        remonitoringfileinfofields.jmethodIDinit = env->GetMethodID(jclassRemonitoringFileInfo, "<init>", "()V");
    }
    LOGE("150330 - CallsetCallbackObject - 9");
    if(jclassRemonitoringFileInfo != NULL && remonitoringfileinfofields.jfieldIDstrFileName != NULL &&
        remonitoringfileinfofields.jfieldIDstrFileTime != NULL && remonitoringfileinfofields.jfieldIDnCanPlay != NULL
        && remonitoringfileinfofields.jmethodIDinit != NULL)
    {
        jbremonitoringfileinfostate = JNI_TRUE;
    }
    else
    {
        JNU_ThrowByName(env, kClassNameOutOfNullPointerException, remonitoringfileinfoexceptiondescript);
    }
    */
    jclassAlarmRecord = (jclass)env->NewGlobalRef(env->FindClass(kClassNameAlarmRecord));    
    if(jclassAlarmRecord != NULL)
    {
        alarmrecordfields.jfieldIDstrDevId = env->GetFieldID(jclassAlarmRecord,"strDevID","Ljava/lang/String;");
        alarmrecordfields.jfieldIDsalarmType = env->GetFieldID(jclassAlarmRecord,"alarmType","S");
        alarmrecordfields.jfieldIDstrAlarmTime = env->GetFieldID(jclassAlarmRecord,"strAlarmTime","Ljava/lang/String;");
        alarmrecordfields.jfieldIDstrFileName = env->GetFieldID(jclassAlarmRecord,"strFileName","Ljava/lang/String;");
        alarmrecordfields.jfieldIDFileSize = env->GetFieldID(jclassAlarmRecord,"strFileSize","Ljava/lang/String;");
        alarmrecordfields.jfieldIDPlayUrl = env->GetFieldID(jclassAlarmRecord,"strPlayUrl","Ljava/lang/String;");
        alarmrecordfields.jmethodIDinit = env->GetMethodID(jclassAlarmRecord, "<init>", "()V");
    }    
    if(jclassAlarmRecord != NULL && alarmrecordfields.jfieldIDstrDevId != NULL &&
        alarmrecordfields.jfieldIDsalarmType != NULL && alarmrecordfields.jfieldIDstrFileName != NULL &&
        alarmrecordfields.jfieldIDsalarmType != NULL && alarmrecordfields.jfieldIDFileSize != NULL
        &&alarmrecordfields.jfieldIDPlayUrl != NULL && alarmrecordfields.jmethodIDinit != NULL)
    {
        jbalarmrecordstate = JNI_TRUE;
    }
    else
    {
        JNU_ThrowByName(env, kClassNameOutOfNullPointerException, alarmrecordexceptiondescript);
    }
    env->DeleteLocalRef(cls);
}

static void Release(JNIEnv *env, jobject thiz)
{
    if (Network_Callback != NULL)
        env->DeleteGlobalRef(Network_Callback);
    if(jclassDeviceStatusInfo != NULL)
    {
        env->DeleteGlobalRef(jclassDeviceStatusInfo);
    }
    if(jclassRemonitoringFileInfo != NULL)
    {
        env->DeleteGlobalRef(jclassRemonitoringFileInfo);
    }
    Network_Callback = NULL;    
}

static const JNINativeMethod gMethods[] = {
{"native_init", "()V", (void*)native_init},
{"startNetwork", "(Ljava/lang/String;CLjava/lang/String;S)V", (void*)CallStartNetwork},
{"closeNetwork", "()V", (void*)CallCloseNetwork},
{"cancelAlarmInfo", "(Ljava/lang/String;Ljava/lang/String;)V", (void*)CallCancelAlarmInfo},
{"getDeviceStatus", "()V", (void*)CallGetDeviceStatus},
{"getVehicleStatus", "(Ljava/lang/String;)V", (void*)CallGetVehicleStatus},
{"realtimeMonitorVideoStream", "(Ljava/lang/String;I)V", (void*)CallRealtimeMonitorVideoStream},
{"getAlarmRecord", "(Ljava/lang/String;IIIIIIIII)V", (void*)CallGetAlarmRecord},
{"downloadVideo", "(Ljava/lang/String;IIILjava/lang/String;)V", (void*)CallDownloadVideo},
{"openGpsInfo", "(Ljava/lang/String;)V", (void*)CallOpenGPSInfo},
{"closeGpsInfo", "(Ljava/lang/String;)V", (void*)CallCloseGPSInfo},
{"snapShot", "(Ljava/lang/String;)V", (void*)CallSnapShotFile},
{"uploadFile", "(IIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",(void*)CallUploadFile},
{"setCallbackObject", "(Lcom/apical/aiproforcloud/networklibrary/Callback;)V", (void*)CallsetCallbackObject},
{"release", "()V", (void*)Release},
};

JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void *reserved)
{
LOGE("EventHandler: JNI_OnLoad ");
JNIEnv* env = NULL;
myVm = vm;
jint result = -1;
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
  return -1;
jclass clazz;

clazz = env->FindClass(kClassNameNetwork);

if(clazz == NULL)
{
  return -1;
}

if(env->RegisterNatives(clazz,gMethods, sizeof(gMethods)/sizeof(gMethods[0]))!= JNI_OK)
{
  return -1;
}
return JNI_VERSION_1_4;
}