---

VoiceDev.h

Go to the documentation of this file.

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

#ifndef _BOGOTEL_VOICEDEV_H
#define _BOGOTEL_VOICEDEV_H

#include <log4cpp/Portability.hh>
#include <bogotel/devbase.h>
#include <bogotel/observer.h>
#include <bogotel/Properties.h>

#include <bogotel/StlHelp.h>

#include <boost/thread/recursive_mutex.hpp>

#include <string>
#include <map>
#include <queue>
#include <deque>

namespace bogotel {

    typedef std::map<int, std::string, std::less<int> > MAP_INT2STR;
    typedef std::queue<char> QUEUE_CHAR;
    typedef std::deque<char> DEQUE_CHAR;

    class CSignalDev;
    class CIOOp;

    class CVoiceDev : public CDevBase, public CSubject
    {
    public:

        static const int invalidHandle;

        enum targetType {
            local = 0,
            remote
        };

        enum speakerState {
            UNDEFINED = -1,
            SILENT,
            WAV,
            DTMF
        };

        CVoiceDev(CBgtRt *pBgtRt);
        int init(std::string strName, long lHandle, long lTimeslot);
        int listen(CSignalDev *pVD);
        int play(DX_IOTT *pIott,const DV_TPT *pTpt,const DX_XPB *pXpb,unsigned short usMode);
        int dial(const char *szDialStr, const DX_CAP *pCAP, unsigned short usMode);
        int stop(unsigned short usMode);
        int clearDigitBuffer();
        int getDigit(const DV_TPT *pTpt, DV_DIGIT *pDigit, unsigned short usMode);

        long getSignalHandle();
        long getTimeslot()       { return m_lSCbusTimeslot; }
        long getHandle()         { return m_lHandle; }
        speakerState getState()  { return m_speakerState; }
        char getCurrentDtmf()    { return m_queueDigitValue.front(); }
        long getTermMsk()        { return m_lTermMsk; }
        unsigned int getStateId() { return m_uiStateId; }

        void truncateDtmfs(int iNumToTruncate);

        int receiveMsg(CMsg *pMsg);
        void sendPlayMsg(std::string strFilename);
        void sendPlayFinishedMsg();
        void sendDtmfMsg(char chDTMF, int iTargetType);
        void sendDtmfFinishedMsg(int iTargetType);
        void terminateIoOp(long lTermMsk, bool bInternalIoOp = false);

        void eraseDigitHistory();
        void eraseFromDigitHistory(unsigned short iToChop);
        void eraseFromDigitHistory(DEQUE_CHAR::iterator iterTillToChop);
        DEQUE_CHAR getDigitHistory() { return m_dequeDigitHistory; }
        static const std::string& getEventName(long lType);

        void getDigits(DV_DIGIT *pDigit, int iNumToGet);

        // stores the filenames of all opened WAV files, indexed by handles
        static MAP_INT2STR s_mapHandle2Filename;
        static CProperties s_propWav2Dtmfs;
        static std::string s_strWavFilenameBase;

    protected:
        // stores the digits "heard" from DTMFs
        QUEUE_CHAR   m_queueDigitValue;
        QUEUE_CHAR   m_queueDigitType;
        // used to determine termination conditions
        DEQUE_CHAR   m_dequeDigitHistory;

        speakerState m_speakerState;
        // Identifies the current state, allowing
        // termparm objects to ignore updates to speaker
        // state that don't apply to them.
        unsigned int m_uiStateId;

        std::string  m_strName;
        long         m_lHandle;
        long         m_lSCbusTimeslot;
        CSignalDev*  m_pSignalDev;
        long         m_lTermMsk;

        std::string  m_strCurrPlaybackFilename;
        CIOOp*       m_pIoOp;
        CIOOp*       m_pInternalIoOp;

        int checkDigits();

        int sendEvent(long lType, long lTermMsk = 0);
        int sendMsg(CMsg *pMsg, int targetType = targetType::remote);
        void log(int iLevel, char *szFmt, ...);
        void getEvtTypeString(long lType, char *szType, int iMaxLen);

    private:

        // manages multithreaded access to the IO op pointers
        boost::recursive_mutex m_mtxIoOps; 

        void registerIoOp(CIOOp *pIoOp, bool bInternalIoOp = false);
        void stripBaseFromWavFilename(std::string& strFilename);
        bool attemptRecognition(std::string& strFilename);

        void updateSpeakerState(speakerState state);
        void updateSpeakerState(speakerState state, char chDtmf);
        void updateSpeakerState(speakerState state, std::string strFilename);

        static const std::string eventNames[5];
    };

}

#endif // ! _BOGOTEL_VOICEDEV_H

---