---

DialOp.cpp

Go to the documentation of this file.

/*
 * DialOp.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/dialOp.h>

#include <sys/stat.h>
#include <sys/types.h>

#include <bogotel/BgtErrors.h>
#include <bogotel/voicedev.h>
#include <bogotel/util.h>

namespace bogotel {

    const char *CDialOp::s_szValidDtmf = "1234567890*#abcd,";
    const char *CDialOp::s_szName      = "CDialOp";

    CDialOp::CDialOp(CVoiceDev* pVD, const char *szDialStr, int iTargetType) throw (std::invalid_argument) :
    CIOOp(pVD),
    m_iCurrDtmf(0),
    m_strDtmf(szDialStr),
    m_iTargetType(iTargetType)
    {
        checkDialString();
    }

    CDialOp::~CDialOp()
    {
        CIOOp::~CIOOp();
    }

    void CDialOp::start() 
    {
        dialSingleDigit();
    }

    std::string CDialOp::toString()
    {
        return CTimerTarget::toString() + " " + s_szName;
    }

    long CDialOp::terminationEvent()
    {
        return TDX_DIAL;
    }

    // this is called when a dtmf has finished playing
    // and it means that it is time to play the next one
    void CDialOp::_timerExpired(int timerType, int stateId)
    {
        char method[] = "CDialOp::_timerExpired";
        switch (timerType) {
        case timerType::singleDtmf:
            dialSingleDigit();
            break;
        default:
            log(3, "%s: Invalid timerType", method, timerType);
            break;
        }
    }

    void CDialOp::dialSingleDigit()
    {
        char method[] = "CDialOp::dialSingleDigit";
        g_util->log(9, -1, "%s: Entered. m_strDtmf='%s', m_iCurrDtmf=%d", method, 
            m_strDtmf.c_str(), m_iCurrDtmf);

        // check if we're finished with all digits
        if (m_iCurrDtmf == m_strDtmf.size()) {
            // check if the previous digit was not a pause
            if (m_iCurrDtmf > 0 && m_strDtmf[m_iCurrDtmf - 1] != ',') {
                // send msg that the previous Dtmf has finished playing
                m_pVD->sendDtmfFinishedMsg(m_iTargetType);
            }
            terminate(TM_NORMTERM);
            g_util->log(9, -1, "%s: Finished (terminated)", method);
            return;
        }

        // check if we should perform "pause" (silence)
        if (m_iCurrDtmf > 0 && m_strDtmf[m_iCurrDtmf] == ',' && m_strDtmf[m_iCurrDtmf - 1] != ',') {
            m_pVD->sendDtmfFinishedMsg(m_iTargetType);
        } else {
            m_pVD->sendDtmfMsg(m_strDtmf[m_iCurrDtmf], m_iTargetType);
        }

        // schedule timer for end of Dtmf
        setTimer(700, timerType::singleDtmf);

        m_iCurrDtmf++;
        g_util->log(9, -1, "%s: Finished", method);
    }

    // override terminate so that we can check the target
    void CDialOp::terminate(long lTermMsk)
    {
        char method[] = "CDialOp::terminate";
        switch (m_iTargetType) {
        case CVoiceDev::targetType::remote:
            CIOOp::terminate(lTermMsk);
            break;
        case CVoiceDev::targetType::local:
            m_pVD->terminateIoOp(lTermMsk, true);
            break;
        default:
            log(3, "%s: Invalid targetType", method, m_iTargetType);
            break;
        }
    }

    // makes sure that all chars in dial string are valid
    void CDialOp::checkDialString() throw (std::invalid_argument)
    {
        if (m_strDtmf.size() == 0) {
            throw std::invalid_argument("Dtmf string is empty");
        }
        for (std::string::size_type i = 0; i < m_strDtmf.size(); i++) {
            if (strchr(s_szValidDtmf, m_strDtmf[i]) == NULL) {
                throw std::invalid_argument("Invalid char in dial string: " + m_strDtmf);
            }
        }
    }
}

---