---

LibBogoTel.cpp

Go to the documentation of this file.

/*
 * LibBogoTel.cpp
 *
 * Copyright 2003, MobileSpear Inc. (www.mobilespear.com). All rights reserved.
 * Copyright 2003, David Resnick. All rights reserved.
 *
 * See the file doc\license.txt for the terms of usage and distribution.
 */

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

#include <bogotel/Portability.h>
#include <bogotel/BgtRt.h>
#include <bogotel/BgtErrors.h>

#include <bogotel/LibBogoTel.h>

// SRL API's

namespace bogotel {

    LIBBOGOTEL_API int sr_enbhdlr(long dev, unsigned long event_type, long (*hdlr)(unsigned long parm))
    {
        return CBgtRt::Instance()->enableHandler(dev, event_type, hdlr);
    }

    LIBBOGOTEL_API int sr_dishdlr(long dev, unsigned long event_type, long (*hdlr)(unsigned long parm))
    {
        return CBgtRt::Instance()->disableHandler(dev, event_type, hdlr);
    }

    LIBBOGOTEL_API int sr_setparm(long parmid, void* valuep)
    {
        return CBgtRt::Instance()->setMode(parmid, valuep);
    }

    LIBBOGOTEL_API int sr_waitevt(long tmout, long *plRemaining)
    {
        return CBgtRt::Instance()->waitEvent(tmout, plRemaining);
    }

    LIBBOGOTEL_API int sr_getevtdatap(unsigned long evt_handle, void **ppData)
    {
        (*ppData) = NULL;
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int sr_getevtdev(unsigned long evt_handle, long *plHandle)
    {
        return CBgtRt::Instance()->getEvtDevHandle(evt_handle, plHandle);
    }

    LIBBOGOTEL_API int sr_getevttype(unsigned long evt_handle, long *plType)
    {
        return CBgtRt::Instance()->getEvtType(evt_handle, plType);
    }

    LIBBOGOTEL_API int sr_getevtlen(unsigned long evt_handle, long *plLen)
    {
        (*plLen) = 0;
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int sr_putevt(long dev, unsigned long event_type, long len, void *pData, long err)
    {
        return CBgtRt::Instance()->putEvt(dev, event_type, len, pData, err);
    }

    // DX API's

    LIBBOGOTEL_API int dx_open(int *piHandle, const char *szName)
    {
        return CBgtRt::Instance()->openVoiceDev(piHandle, szName);
    }

    LIBBOGOTEL_API int dx_getxmitslot(int iVoiceHandle, long *plTimeslot)
    {
        return CBgtRt::Instance()->getVoiceTimeslot(iVoiceHandle, plTimeslot);
    }

    LIBBOGOTEL_API int dx_listen(int iVoiceHandle, long lTimeslot)
    {
        return CBgtRt::Instance()->listenSignalTimeslot(iVoiceHandle, lTimeslot);
    }

    LIBBOGOTEL_API int dx_fileopen(int *iHandle, const char *szFilename, int iFlags)
    {
        return CBgtRt::Instance()->mediaFileOpen(iHandle, szFilename, iFlags);
    }

    LIBBOGOTEL_API int dx_fileclose(int iHandle)
    {
        return CBgtRt::Instance()->mediaFileClose(iHandle);
    }

    LIBBOGOTEL_API int dx_playiottdata(int iVoiceHandle,DX_IOTT *pIott,const DV_TPT *pTpt, const DX_XPB *pXpb,unsigned short usMode)
    {
        return CBgtRt::Instance()->mediaFilePlay(iVoiceHandle,pIott,pTpt,pXpb,usMode);
    }

    LIBBOGOTEL_API int dx_stopch(int iVoiceHandle, unsigned short usMode)
    {
        return CBgtRt::Instance()->stopVoice(iVoiceHandle,usMode);
    }

    LIBBOGOTEL_API int dx_clrdigbuf(int iVoiceHandle)
    {
        return CBgtRt::Instance()->clearDigitBuffer(iVoiceHandle);
    }

    LIBBOGOTEL_API int dx_getdig(int iVoiceHandle, const DV_TPT *pTpt, DV_DIGIT *pDigit, unsigned short usMode)
    {
        return CBgtRt::Instance()->getDigit(iVoiceHandle, pTpt, pDigit, usMode);
    }

    LIBBOGOTEL_API int dx_dial(int iHandle, const char *pDialStr, const DX_CAP *pCAP, unsigned short usMode)
    {
        return CBgtRt::Instance()->dial(iHandle, pDialStr, pCAP, usMode);
    }

    LIBBOGOTEL_API int ATDX_TERMMSK(INT iVoiceHandle, long *lMask)
    {
        return CBgtRt::Instance()->getTermMsk(iVoiceHandle, lMask);
    }

    // GC API's

    LIBBOGOTEL_API int gc_Start()
    {
        if (CBgtRt::Instance() == NULL) {
            return resultERROR;
        }
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_Stop()
    {
        // this will delete the BgtRt singleton
        delete CBgtRt::Instance();
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_OpenEx(LINEDEV *pHandle, char *szName, void *pUsrattr)
    {
        return CBgtRt::Instance()->openSignalDev(pHandle, szName, pUsrattr);
    }

    LIBBOGOTEL_API int gc_Open(LINEDEV *pHandle, char *szName)
    {
        return CBgtRt::Instance()->openSignalDev(pHandle, szName, NULL);
    }

    LIBBOGOTEL_API int gc_GetMetaEvent(METAEVENT *pMetaevent)
    {
        int rc;
        if ((rc = CBgtRt::Instance()->getEvtVoiceDevHandle(0, &pMetaevent->evtdev)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::Instance()->getEvtSignalDevHandle(0, &pMetaevent->linedev)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::Instance()->getEvtUsrAttr(0, &pMetaevent->usrattr)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::Instance()->getEvtType(0, &pMetaevent->evttype)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::Instance()->getEvtFlags(&pMetaevent->flags)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::Instance()->getEvtCrn(&pMetaevent->crn)) != resultSUCCESS) {
            return rc;
        }
        pMetaevent->evtdatap = NULL;
        pMetaevent->evtlen = 0;
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_GetCRN(CRN *pCrn, METAEVENT *pMetaevent)
    {
        (*pCrn) = pMetaevent->crn;
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_GetXmitSlot(LINEDEV hSignal, SC_TSINFO *pScTsInfo)
    {
        return CBgtRt::Instance()->getSignalTimeslot(hSignal, pScTsInfo);
    }

    LIBBOGOTEL_API int gc_Listen(LINEDEV hSignal, SC_TSINFO *pScTsInfo)
    {
        return CBgtRt::Instance()->listenVoiceTimeslot(hSignal, pScTsInfo);
    }

    LIBBOGOTEL_API int gc_GetUsrAttr(LINEDEV linedev, void  **usr_attrp)
    {
        return CBgtRt::Instance()->getUsrAttr(linedev, usr_attrp);
    }

    LIBBOGOTEL_API int gc_WaitCall(LINEDEV hSignal, CRN *pCrn, GC_WAITCALL_BLK *pWaitcall,int iTimeout, unsigned long ulMode)
    {
        return CBgtRt::Instance()->waitCall(hSignal, pCrn, iTimeout, ulMode);
    }

    LIBBOGOTEL_API int gc_GetANI(CRN crn, char *szAni)
    {
        return CBgtRt::Instance()->getAni(crn, szAni);
    }

    LIBBOGOTEL_API int gc_GetDNIS(CRN crn, char *szDnis)
    {
        return CBgtRt::Instance()->getDnis(crn, szDnis);
    }

    LIBBOGOTEL_API int gc_MakeCall(LINEDEV hSignal, CRN *pCrn, char *szNumber, GC_MAKECALL_BLK *pMakecall, int iTimeout, unsigned long ulMode)
    {
        return CBgtRt::Instance()->makeCall(hSignal, pCrn, szNumber, pMakecall, iTimeout, ulMode);
    }

    LIBBOGOTEL_API int gc_SetCallingNum(LINEDEV hSignal, char *szCallingNum)
    {
        return CBgtRt::Instance()->setCallingNum(hSignal, szCallingNum);
    }

    LIBBOGOTEL_API int gc_AcceptCall(CRN crn, int iRings, unsigned long ulMode)
    {
        return CBgtRt::Instance()->acceptCall(crn, iRings, ulMode);
    }

    LIBBOGOTEL_API int gc_AnswerCall(CRN crn, int iRings, unsigned long ulMode)
    {
        return CBgtRt::Instance()->answerCall(crn, iRings, ulMode);
    }

    LIBBOGOTEL_API int gc_DropCall(CRN crn, int iCause, unsigned long ulMode)
    {
        return CBgtRt::Instance()->dropCall(crn, iCause, ulMode);
    }

    LIBBOGOTEL_API int gc_ReleaseCallEx(CRN crn, unsigned long ulMode)
    {
        return CBgtRt::Instance()->releaseCall(crn, ulMode);
    }

    LIBBOGOTEL_API int gc_ResultValue(METAEVENT *pMetaEvent, int *piGcResult, int *pCcLibId, long *pCcLibResult)
    {
        return CBgtRt::Instance()->resultValue(pMetaEvent, piGcResult, pCcLibId, pCcLibResult);
    }

    LIBBOGOTEL_API int gc_ResetLineDev(LINEDEV hSignal, unsigned long mode)
    {
        return CBgtRt::Instance()->resetLineDev(hSignal, mode);
    }

    LIBBOGOTEL_API int gc_CCLibStatusEx(char *szCcLibName, void *pCcLibInfo)
    {
        if (! strcmp(szCcLibName, "GC_ALL_LIB")) {
            GC_CCLIB_STATUSALL* pCcLib = static_cast<GC_CCLIB_STATUSALL*>(pCcLibInfo);
            char szTemp[20];

            // return that all libraries are configured
            for (int i = 0; i < GC_TOTAL_CCLIBS; i++) {
                sprintf(szTemp, "Lib %d", i);
                strcpy(pCcLib->cclib_state[i].name, szTemp);
                pCcLib->cclib_state[i].state = GC_CCLIB_CONFIGURED;
            }
        } else {
            int* iState = static_cast<int*>(pCcLibInfo);
            (*iState) = GC_CCLIB_CONFIGURED;
        }
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_ResultInfo(METAEVENT *pMetaevent, GC_INFO *pGcInfo)
    {
        int rc;
        if ((rc = CBgtRt::Instance()->resultValue(pMetaevent, &pGcInfo->gcValue, &pGcInfo->ccLibId, 
            &pGcInfo->ccValue)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::resultMsg(pGcInfo->gcValue, &pGcInfo->gcMsg,
            pGcInfo->ccValue, &pGcInfo->ccMsg)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::ccLibIDToName(pGcInfo->ccLibId, &pGcInfo->ccLibName)) != resultSUCCESS) {
            return rc;
        }
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_ErrorInfo(GC_INFO *pGcInfo)
    {
        int rc;
        if ((rc = CBgtRt::Instance()->errorValue(&pGcInfo->gcValue, &pGcInfo->ccLibId, 
            &pGcInfo->ccValue)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::resultMsg(pGcInfo->gcValue, &pGcInfo->gcMsg,
            pGcInfo->ccValue, &pGcInfo->ccMsg)) != resultSUCCESS) {
            return rc;
        }
        if ((rc = CBgtRt::ccLibIDToName(pGcInfo->ccLibId, &pGcInfo->ccLibName)) != resultSUCCESS) {
            return rc;
        }
        return resultSUCCESS;
    }

    LIBBOGOTEL_API int gc_ErrorValue(int *piError, int *piCcLib, long *plCcLibErr)
    {
        return CBgtRt::Instance()->errorValue(piError, piCcLib, plCcLibErr);
    }

    LIBBOGOTEL_API int gc_CCLibIDToName(int iCcLibId, char **pszCcLibName)
    {
        return CBgtRt::ccLibIDToName(iCcLibId, pszCcLibName);
    }

    LIBBOGOTEL_API int gc_ResultMsg(int iCcLibId, long lResultCode, char **pszMsg)
    {
        return CBgtRt::resultMsg(iCcLibId, lResultCode, pszMsg);
    }

    // DTI API's

    LIBBOGOTEL_API int dt_getxmitslot(LINEDEV hSignal, SC_TSINFO *pScTsInfo)
    {
        return CBgtRt::Instance()->getSignalTimeslot(hSignal, pScTsInfo);
    }

    LIBBOGOTEL_API int dt_listen(LINEDEV hSignal, SC_TSINFO *pScTsInfo)
    {
        return CBgtRt::Instance()->listenVoiceTimeslot(hSignal, pScTsInfo);
    }

}

---