---

VoiceDev.cpp

Go to the documentation of this file.

/*
 * VoiceDev.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 <bogotel/Portability.h>
#include <bogotel/VoiceDev.h>
#include <bogotel/BgtErrors.h>
#include <bogotel/SignalDev.h>
#include <bogotel/util.h>
#include <bogotel/Timer.h>
#include <bogotel/playop.h>
#include <bogotel/dialop.h>
#include <bogotel/getdigop.h>

namespace bogotel {

    MAP_INT2STR CVoiceDev::s_mapHandle2Filename;
    std::string CVoiceDev::s_strWavFilenameBase;
    CProperties CVoiceDev::s_propWav2Dtmfs;
    const int CVoiceDev::invalidHandle = -1;

    CVoiceDev::CVoiceDev(CBgtRt *pBgtRt) :
    CDevBase(pBgtRt),
    m_lSCbusTimeslot(-1),
    m_lHandle(invalidHandle),
    m_pSignalDev(NULL),
    m_lTermMsk(0),
    m_pIoOp(NULL),
    m_pInternalIoOp(NULL),
    m_speakerState(speakerState::SILENT),
    m_uiStateId(0)
    {
    }

    int CVoiceDev::init(std::string strName, long lHandle, long lTimeslot)
    {
        int rc;
        if ((rc = CDevBase::init()) != resultSUCCESS) {
            return rc;
        }

        m_strName = strName;
        m_lHandle = lHandle;
        m_lSCbusTimeslot = lTimeslot;
        return resultSUCCESS;
    }

    int CVoiceDev::listen(CSignalDev *pSD)
    {
        if (m_pSignalDev != NULL) {
            return resultPOINTER;
        }
        m_pSignalDev = pSD;
        
        return resultSUCCESS;
    }

    // Starts playback of WAVs whose filehandles are stored in IOTT structure.
    int CVoiceDev::play(DX_IOTT *pIott, const DV_TPT *pTpt, const DX_XPB *pXpb, unsigned short usMode)
    {
        char method[] = "CVoiceDev::play";
        // we only work in asyncronous mode
        if (usMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        try {
            registerIoOp(new CPlayOp(this, pIott, pTpt));
        } catch (...) {
            log(3, "%s(): CVoiceDev::registerIoOp threw an exception", method);
            return resultFAIL;
        }

        return resultSUCCESS;
    }

    // Starts dialing of DTMF digits
    int CVoiceDev::dial(const char *szDialStr, const DX_CAP *pCAP, unsigned short usMode)
    {
        char method[] = "CVoiceDev::dial";
        // we only work in asyncronous mode
        if (usMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }
        try {
            registerIoOp(new CDialOp(this, szDialStr, targetType::remote));
        } catch (std::invalid_argument& x) {
            log(3, "%s(): new CDialOp threw an invalid_argument exception. %s", method,
                x.what());
            return resultFAIL;
        } catch (...) {
            log(3, "%s(): CVoiceDev::registerIoOp threw an exception", method);
            return resultFAIL;
        }

        return resultSUCCESS;
    }

    // Sets up state where dtmf tones are listened for.
    // The number of digits waited for is specified in the TPT (termination parameter table).
    int CVoiceDev::getDigit(const DV_TPT *pTpt, DV_DIGIT *pDigit, unsigned short usMode)
    {
        char method[] = "CVoiceDev::getDigit";

        // we only work in asyncronous mode
        if (usMode != EV_ASYNC) {
            return resultFUNC_BAD_PARAMETER;
        }

        CGetDigOp *pOp;
        try {
            pOp = new CGetDigOp(this, pTpt, pDigit);
        } catch (std::invalid_argument& x) {
            log(3, "%s(): new CGetDigOp threw an invalid_argument exception. %s", method,
                x.what());
            return resultFAIL;
        } catch (...) {
            log(3, "%s(): new CGetDigOp threw an exception", method);
            return resultFAIL;
        }

        try {
            registerIoOp(pOp);
        } catch (std::invalid_argument& x) {
            log(3, "%s(): CVoiceDev::registerIoOp threw an invalid_argument exception. %s", method,
                x.what());
            return resultFAIL;
        } catch (...) {
            log(3, "%s(): CVoiceDev::registerIoOp threw an exception", method);
            return resultFAIL;
        }

        return resultSUCCESS;
    }

    // This removes an active IO operation (if any).
    void CVoiceDev::terminateIoOp(long lTermMsk, bool bInternalIoOp)
    {
        char method[] = "CVoiceDev::terminateIoOp";

        boost::recursive_mutex::scoped_lock lock(m_mtxIoOps);

        log(9, "%s: Entered.", method);
        if (bInternalIoOp) {
            if (m_pInternalIoOp) {
                std::string strOpName = m_pInternalIoOp->toString();
                m_pTimer->requestTargetDeletion(m_pInternalIoOp);
                m_pInternalIoOp = NULL;
                log(7, "%s: internal IO op terminated. Op: %s", method,
                    strOpName.c_str());
            }
        } else {
            if (m_pIoOp) {
                std::string strOpName = m_pIoOp->toString();
                sendEvent(m_pIoOp->terminationEvent(), lTermMsk);
                // schedule IO operation for deletion
                m_pTimer->requestTargetDeletion(m_pIoOp);
                m_pIoOp = NULL;
                log(7, "%s: IO op terminated. Op: %s", method,
                    strOpName.c_str());
            }
        }
        log(9, "%s: Completed.", method);
    }

    // Sets parm IO operation as current IO operation.
    // Terminates current IO operation (if any) first
    void CVoiceDev::registerIoOp(CIOOp *pIoOp, bool bInternalIoOp)
    {
        char method[] = "CVoiceDev::registerIoOp";
        log(9, "%s: Entered. Is internal OP? %s", method, bInternalIoOp? "TRUE" : "FALSE");

        boost::recursive_mutex::scoped_lock lock(m_mtxIoOps);

        terminateIoOp(TM_USRSTOP, bInternalIoOp);
        m_pTimer->registerTarget(pIoOp);

        if (bInternalIoOp) {
            m_pInternalIoOp = pIoOp;
        } else {
            m_pIoOp = pIoOp;
        }

        pIoOp->start();
    }

    int CVoiceDev::stop(unsigned short usMode)
    {
        int rc = resultSUCCESS;

        terminateIoOp(TM_USRSTOP);

        log(9, "CVoiceDev::stop() completed.");

        return rc;
    }

    int CVoiceDev::clearDigitBuffer()
    {
        while (! m_queueDigitValue.empty()) {
            m_queueDigitValue.pop();
            m_queueDigitType.pop();
        }
        eraseDigitHistory();

        log(9, "CVoiceDev::clearDigitBuffer() completed.");

        return resultSUCCESS;
    }

    int CVoiceDev::receiveMsg(CMsg *pMsg)
    {
        long hSignal = m_pSignalDev->getHandle();
        char method[] = "CVoiceDev::receiveMsg";

        char szType[30];
        pMsg->getMsgTypeString(szType, sizeof(szType));
        log(7, "%s(): %s type", method, szType);

        switch(pMsg->m_type) {
        case MT_PLAY_WAV: 
            updateSpeakerState(speakerState::WAV, pMsg->getParam(PT_WAV_FILENAME).c_str());
            break;

        case MT_PLAY_WAV_FINISHED:
            // terminate internal OP operation (if any)
            terminateIoOp(TM_USRSTOP, true);
            updateSpeakerState(speakerState::SILENT);
            break;

        case MT_PLAY_DTMF: 
            updateSpeakerState(speakerState::DTMF, pMsg->getParam(PT_DTMF).c_str()[0]);
            break;

        case MT_PLAY_DTMF_FINISHED:
            updateSpeakerState(speakerState::SILENT);
            break;

        default:
            log(3, "%s: Unknown message type: %i",method , pMsg->m_type);
            break;
        }

        log(9, "%s completed.", method);
        return resultSUCCESS;
    }

    void CVoiceDev::updateSpeakerState(speakerState state, std::string strFilename)
    {
        m_strCurrPlaybackFilename = strFilename;
        // see if we know that this wav file has actually a string of DTMFs
        if (! attemptRecognition(strFilename)) {
            // no DTMFs recognized -- so we just hear the wav file
            updateSpeakerState(state);
        }
    }

    void CVoiceDev::updateSpeakerState(speakerState state, char chDtmf)
    {
        if (chDtmf == '\0') {
            log(3, "Null as new dtmf char");
            return;
        }
        // append newest DTMF to internal queue, if there is room
        if (m_queueDigitValue.size() < DG_MAXDIGS) {
            m_queueDigitValue.push(chDtmf);
            m_queueDigitType.push(D_DTMF);
        }
        updateSpeakerState(state);
    }

    void CVoiceDev::updateSpeakerState(speakerState state)
    {
        char method[] = "CVoiceDev::updateSpeakerState";
        log(9, "%s entered.", method);

        m_speakerState = state;
        m_uiStateId++;
        switch (state) {
        case speakerState::WAV:
            log(5, "Now hearing WAV file \"%s\"", m_strCurrPlaybackFilename);
            break;
        case speakerState::DTMF:
            log(5, "Now hearing DTMF \"%c\"", m_queueDigitValue.back());
            break;
        case speakerState::SILENT:
            m_strCurrPlaybackFilename = "";
            log(5, "Now hearing nothing.");
            break;
        }
        // call base class to notify all observers of the device
        CSubject::notify();

        log(9, "%s completed.", method);
    }

    // Check if this wav filename is a recording of DTMFs
    // by looking in the map of known wav filenames.
    // If perform dial() with DTMFs recognized if any.
    bool CVoiceDev::attemptRecognition(std::string& strFilename)
    {
        char method[] = "CVoiceDev::attemptRecognition";

        std::string strDtmfs = s_propWav2Dtmfs.getProperty(strFilename);
        if (strDtmfs != "") {

            strDtmfs.append(g_util->m_propIni.getProperty("DtmfDelimiterChar", "d"));

            log(5, "Wav \"%s\" recognized as DTMFs \"%s\"", strFilename.c_str(), 
                strDtmfs.c_str());

            try {
                // start dial operation that will be played on the local
                // voice device, as if DTMFs were heard in place of the wav
                // file that was found.
                if (m_pInternalIoOp != NULL) {
                    log(3, "%s(): m_pInternalIoOp not NULL.", method);
                }
                // register the IoOp as an internal operation
                CIOOp *pIoOp = new CDialOp(this, strDtmfs.c_str(), targetType::local);
                registerIoOp(pIoOp, true);
                return true;
            } catch (...) {
                log(3, "%s(): CVoiceDev::registerIoOp threw an exception", method);
                return false;
            }
        }
        return false;
    }

    int CVoiceDev::sendMsg(CMsg *pMsg, int iTargetType)
    {
        char szType[30];
        pMsg->getMsgTypeString(szType, sizeof(szType));
        log(7, "CVoiceDev::sendMsg(): %s type", szType);
        switch (iTargetType) {
        case targetType::remote:
            return m_pTransport->sendMsg(pMsg);
        case targetType::local:
            return receiveMsg(pMsg);
        default:
            log(3, "CVoiceDev::sendMsg(): Invalid target type");
            return resultFUNC_BAD_PARAMETER;
        }
    }

    void CVoiceDev::sendPlayMsg(std::string strFilename)
    {
        stripBaseFromWavFilename(strFilename);

        m_pMsg->init(MT_PLAY_WAV, MC_VOICE, m_lHandle);
        m_pMsg->addParam(PT_WAV_FILENAME, strFilename);
        if (sendMsg(m_pMsg) != resultSUCCESS) {
            log(3, "CVoiceDev::sendPlayMsg(): sendMsg() failed");
        }
    }

    void CVoiceDev::sendPlayFinishedMsg()
    {
        m_pMsg->init(MT_PLAY_WAV_FINISHED, MC_VOICE, m_lHandle);
        if (sendMsg(m_pMsg) != resultSUCCESS) {
            log(3, "CVoiceDev::sendPlayFinishedMsg(): sendMsg() failed");
        }
    }

    void CVoiceDev::sendDtmfMsg(char chDtmf, int iTargetType)
    {
        char method[] = "CVoiceDev::sendDtmfMsg";

        log(9, "%s: dtmf=%c", method, chDtmf);
        m_pMsg->init(MT_PLAY_DTMF, MC_VOICE, m_lHandle);
        std::string strDtmf;
        strDtmf.push_back(chDtmf);
        m_pMsg->addParam(PT_DTMF, strDtmf);
        if (sendMsg(m_pMsg, iTargetType) != resultSUCCESS) {
            log(3, "CVoiceDev::sendDTMFMsg(): sendMsg() failed");
        }
    }

    void CVoiceDev::sendDtmfFinishedMsg(int iTargetType)
    {
        m_pMsg->init(MT_PLAY_DTMF_FINISHED, MC_VOICE, m_lHandle);
        if (sendMsg(m_pMsg, iTargetType) != resultSUCCESS) {
            log(3, "CVoiceDev::sendDTMFFinishedMsg(): sendMsg() failed");
        }
    }

    void CVoiceDev::stripBaseFromWavFilename(std::string& strFilename)
    {
        if (strFilename.find(s_strWavFilenameBase) == 0) {
            strFilename.erase(0, s_strWavFilenameBase.length());
        }
    }

    int CVoiceDev::sendEvent(long lType, long lTermMask)
    {
        // all events are termination events
        // so we should always set the termmask to
        // a new value when sending an event
        m_lTermMsk = lTermMask;

        CEvt *pEvt = new CEvt();

        pEvt->m_pUsrAttr = NULL;
        pEvt->m_lLen = 0;
        pEvt->m_lType = lType;
        pEvt->m_lVoiceDevHandle = m_lHandle;
        pEvt->m_lSignalDevHandle = m_pSignalDev->getHandle();
        pEvt->m_ulFlags = 0;
        pEvt->m_lCrn = INVALID_CRN;
        pEvt->m_iSysType = CEvt::SysType::DEVICE;

        int rc;
        if ((rc = m_pBgtRt->addEvent(pEvt)) != resultSUCCESS) {
            log(3, "CVoiceDev::sendEvent(): CBgtRt::addEvent failed. rc is %d", rc);
            return rc;
        }
        log(7, "CVoiceDev::sendEvent(): %s type", pEvt->toString().c_str());
        return rc;
    }

    void CVoiceDev::log(int iLevel, char *szFmt, ...)
    {
        va_list vl;
        char szTemp[2000];

        va_start(vl, szFmt);
        _vsnprintf(szTemp, sizeof(szTemp), szFmt, vl);
        va_end(vl);

        g_util->log(iLevel, m_pSignalDev->getHandle(), szTemp);
    }

    long CVoiceDev::getSignalHandle() 
    { 
        return m_pSignalDev->getHandle(); 
    }

    void CVoiceDev::eraseFromDigitHistory(unsigned short iToChop)
    {
        char method[] = "CVoiceDev::eraseFromDigitHistory";

        DEQUE_CHAR::iterator iterTillToChop = m_dequeDigitHistory.begin();
        for (int i = 0; i < iToChop; i++) {
            if (iterTillToChop == m_dequeDigitHistory.end()) {
                log(3, "%s: request to remove more digits than in history. Length of history: %d."
                    " Number to remove: %d", method, m_dequeDigitHistory.size(),
                    iToChop);
                break;
            }
            iterTillToChop++;
        }
        m_dequeDigitHistory.erase(m_dequeDigitHistory.begin(), iterTillToChop);
    }

    void CVoiceDev::eraseFromDigitHistory(DEQUE_CHAR::iterator iterTillToChop)
    {
        m_dequeDigitHistory.erase(m_dequeDigitHistory.begin(), iterTillToChop);
    }

    void CVoiceDev::eraseDigitHistory()
    {
        m_dequeDigitHistory.erase(m_dequeDigitHistory.begin(), m_dequeDigitHistory.end());
    }

    void CVoiceDev::getDigits(DV_DIGIT *pDigit, int iNumToGet)
    {
        char method[] = "CVoiceDev::getDigits";

        log(9, "%s: Entered.", method);

        // do some sanity checks
        if (iNumToGet > DG_MAXDIGS) {
            log(5, "%s: request to get more digits than DG_MAXDIGS. Number requested: %d.",
                method, iNumToGet);
            iNumToGet = DG_MAXDIGS;
        }
        if (iNumToGet > static_cast<int>(m_queueDigitValue.size())) {
            log(5, "%s: request to get more digits than in buffer. Number requested: %d."
                " Number in buffer: %d", method, iNumToGet, m_dequeDigitHistory.size());
            iNumToGet = m_queueDigitValue.size();
        }

        for (int i = 0; i < iNumToGet; i++) {
            pDigit->dg_value[i] = m_queueDigitValue.front();
            m_queueDigitValue.pop();
            pDigit->dg_type[i] = m_queueDigitType.front();
            m_queueDigitType.pop();
        }
        pDigit->dg_value[iNumToGet] = '\0';
        pDigit->dg_type[iNumToGet] = (char)DG_END;
    }

    const std::string& CVoiceDev::getEventName(long lType)
    {
        switch(lType) {
        case TDX_PLAY:   return eventNames[0];
        case TDX_GETDIG: return eventNames[1];
        case TDX_ERROR:  return eventNames[2];
        case TDX_DIAL:   return eventNames[3];
        default:         return eventNames[4];
        }
    }

    const std::string CVoiceDev::eventNames[5] = {
        "TDX_PLAY",
        "TDX_GETDIG",
        "TDX_ERROR",
        "TDX_DIAL",
        "Unknown"
    };

}

---