gcprovider.c

jtapi for telephone

        miscEventID = (*env)->GetMethodID(env, clst, "miscEvent", "(II)V");
        alertingID = (*env)->GetMethodID(env, clst, "alerting", "(I)V");
        unblockedID = (*env)->GetMethodID(env, clst, "unblocked", "(I)V");
        blockedID = (*env)->GetMethodID(env, clst, "blocked", "(I)V");
        offeredID = (*env)->GetMethodID(env, clst, "offered", "(I)V");
        openedID = (*env)->GetMethodID(env, clst, "opened", "(I)V");
        acceptID = (*env)->GetMethodID(env, clst, "accept", "(I)V");
        taskFailID = (*env)->GetMethodID(env, clst, "taskFail", "(I)V");
        answeredID = (*env)->GetMethodID(env, clst, "answered", "(I)V");
        dropCallID = (*env)->GetMethodID(env, clst, "dropCall", "(I)V");
        releaseCallID = (*env)->GetMethodID(env, clst, "releaseCall", "(I)V");
        releaseCallFailID = (*env)->GetMethodID(env, clst, "releaseCallFail", "(I)V");
        callStatusID = (*env)->GetMethodID(env, clst, "callStatus", "(I)V");
        connectedID = (*env)->GetMethodID(env, clst, "connected", "(I)V");
        disconnectedID = (*env)->GetMethodID(env, clst, "disconnected", "(I)V");
        openFailedID = (*env)->GetMethodID(env, clst, "openFailed", "(I)V");
        alertingID = (*env)->GetMethodID(env, clst, "alerting", "(I)V");
        proceedingID = (*env)->GetMethodID(env, clst, "proceeding", "(I)V");
        createCallID = (*env)->GetMethodID(env, clst, "createDCall", "(IILjava/lang/String;Ljava/lang/String;)V");
    }
    return(res);  
}

/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_OpenEx
 * Signature: (Ljava/lang/String;ZJ)I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1OpenEx
  (JNIEnv *env, jobject obj, jstring Sline, jboolean sync, jlong key)
{
    int ret;
    int mode = EV_ASYNC;
    char *name;
    LINEDEV line = -1;
    
    name =(char *) (*env)->GetStringUTFChars(env, Sline, 0);
    if(sync) {
      mode = EV_SYNC;
    }
    sr_hold();
    ret = gc_OpenEx(&line, name, mode, (void *) 0);
    if (ret != GC_SUCCESS){
        print_error("OpenEx");
        throw(env, "java/lang/RuntimeException", "GC OpenEX error");
    }
    sr_release();
    (*env)->ReleaseStringUTFChars(env, Sline, name);

    return line;

}




/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    srlibinit
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_srlibinit
  (JNIEnv *env , jobject obj, jboolean poll)
{
    int gotvm;
    int par,ret ;

	ret = 0;
#ifndef WIN32
    /* Reference symbols to get them loaded  - pulls in LiS */
    if (0) {
        getpmsg(0);
        putpmsg(0);
    }
#endif
    
    gotvm = (*env)->GetJavaVM(env, &vm);
    if (gotvm < 0) {
        throw(env, "java/lang/RuntimeException",
                    "VM reference error!");
        return -1;
    }  else {
      printf("gotvm \n", ret);
    }
    if (GC_SUCCESS != (ret = gcinit(env,obj))) {
        printf("gc_Start returned %d \n", ret);
        print_error("gc_Start");
        print_all_cclibs_status();
        throw(env, "java/lang/RuntimeException", "GClib start error");
        return -1;
    }
    if (poll) {
        par = SR_POLLMODE;
    } else {
        par = SR_SIGMODE;
    }
    if( sr_setparm( SRL_DEVICE, SR_MODEID, &par ) == -1 ) {
        throw(env, "java/lang/RuntimeException", "SRL MODE init error");
        return -1;
    }

    if (sr_enbhdlr(EV_ANYDEV, EV_ANYEVT, handleEvent ) == -1 ) {
        throw(env, "java/lang/RuntimeException", "SRL handler registration error");
        return -1;
    }

    return 0;
}

/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    sr_waitevt
 * Signature: (J)I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_sr_1waitevt
  (JNIEnv *env, jobject obj, jlong delay){

  int res = 0;
  res = sr_waitevt(delay);
  return res;
}


/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_stop
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1stop
  (JNIEnv *env, jobject obj){

  int res = 0;
  res = gc_Stop();
  return res;
}

/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_AcceptCall
 * Signature: (IIZ)I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1AcceptCall
  (JNIEnv *env, jobject obj, jint crn, jint rings, jboolean sync){
    
    int ret;
    int mode = EV_ASYNC;
    if(sync) {
      mode = EV_SYNC;
    }
    sr_hold();
    ret = gc_AcceptCall(crn, rings, mode);
    if (ret != GC_SUCCESS){
        print_error("AcceptCall");
        throw(env, "java/lang/RuntimeException", "AcceptCall error");
    }
    sr_release();
    return ret;  
}

/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_AnswerCall
 * Signature: (IIZ)I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1AnswerCall
  (JNIEnv *env, jobject obj, jint crn, jint rings, jboolean sync){
      
    int ret;
    int mode = EV_ASYNC;
    if(sync) {
      mode = EV_SYNC;
    }
    sr_hold();
    ret = gc_AnswerCall(crn, rings, mode);
    if (ret != GC_SUCCESS){
        print_error("AnswerCall");
        throw(env, "java/lang/RuntimeException", "AnswerCall error");
    }
    sr_release();
    return ret;  
}
/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_DropCall
 * Signature: (IZZ)I
 *  static native int gc_DropCall(int crn, boolean normalcause,boolean sync);
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1DropCall
  (JNIEnv *env, jobject obj, jint crn , jboolean normalcause , jboolean sync){
      
    int ret;
    int cause = GC_NORMAL_CLEARING;
    int mode = EV_ASYNC;
    if(sync) {
      mode = EV_SYNC;
    }
    if(!normalcause) {
        cause = GC_DEST_OUT_OF_ORDER; /* just pick a random - non-normal cause */
    }
    sr_hold();
    ret = gc_DropCall(crn, cause, mode);
    if (ret != GC_SUCCESS){
        print_error("DropCall");
        throw(env, "java/lang/RuntimeException", "DropCall error");
    }
    sr_release();
    return ret;  
}

/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_ReleaseCallEx
 * Signature: (IZ)I
 * static native int gc_ReleaseCallEx(int crn, boolean sync);
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1ReleaseCallEx
  (JNIEnv *env, jobject obj, jint crn, jboolean sync){
      
    int ret;
    int mode = EV_ASYNC;
    if(sync) {
      mode = EV_SYNC;
    }
    sr_hold();
    ret = gc_ReleaseCallEx(crn, mode);
    if (ret != GC_SUCCESS){
        print_error("ReleaseCallEx");
        throw(env, "java/lang/RuntimeException", "ReleaseCallEx error");
    }
    sr_release();
    return ret;  
}
/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_MakeCall
 * Signature: (ILjava/lang/String;IZ)I
 * static native int gc_MakeCall(int linedev, String numberstr, int timeout, boolean sync);    
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1MakeCall
  (JNIEnv *env, jobject obj, jint line, jstring numberstr, jint timeout, jboolean sync){
    int ret;
    int mode = EV_ASYNC;
    CRN crn;
    char *num;
    
    num =(char *) (*env)->GetStringUTFChars(env, numberstr, 0);
    if(sync) {
      mode = EV_SYNC;
    }
    sr_hold();
    /* (linedev, crnp, numberstr, makecallp, timeout, mode) */
    ret = gc_MakeCall((LINEDEV)line,&crn,num,NULL,(int)timeout,mode);
    if (ret != GC_SUCCESS){
        print_error("MakeCall");
        throw(env, "java/lang/RuntimeException", "MakeCall error");
    }
    sr_release();

    (*env)->ReleaseStringUTFChars(env, numberstr, num);

    return crn;
}
/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_WaitCall
 * Signature: (IIZ)I
 *   static native int gc_WaitCall(int linedev, int timeout, boolean sync);     
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1WaitCall
  (JNIEnv *env, jobject obj, jint line, jint timeout, jboolean sync){
    int ret;
    int mode = EV_ASYNC;
    CRN *crnp = NULL;
    CRN crn;
    
    if(sync) {
      mode = EV_SYNC;
      crnp = &crn;
    }
    sr_hold();
    ret = gc_WaitCall((LINEDEV)line,crnp,NULL,(int)timeout,mode);
    if (ret != GC_SUCCESS){
        print_error("WaitCall");
        throw(env, "java/lang/RuntimeException", "MakeCall error");
    }
    sr_release();
    return ret;
}
/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    resetLine
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_resetLine
  (JNIEnv *env, jobject obj, jint line){
    int ret;
    int mode = EV_SYNC;
    
    sr_hold();
    ret = gc_ResetLineDev(line, mode) ;
    if (ret != GC_SUCCESS){
        print_error("ResetLineDev");
        throw(env, "java/lang/RuntimeException", "ResetLineDev error");
    }
    sr_release();
    return ret;
}
/*
 * Class:     net_sourceforge_gjtapi_raw_dialogic_GCProvider
 * Method:    gc_Close
 * Signature: (I)I
 */
JNIEXPORT jint JNICALL Java_net_sourceforge_gjtapi_raw_dialogic_GCProvider_gc_1Close
  (JNIEnv *env, jobject obj, jint line){
  
    int ret;
    sr_hold();
    ret = gc_Close((LINEDEV)line);
    if (ret != GC_SUCCESS){
        print_error("Close");
        throw(env, "java/lang/RuntimeException", "Close error");
    }
    sr_release();
    return ret;
}