yatephone.h

#ifndef __YATEPHONE_H
#define __YATEPHONE_H

#ifndef __cplusplus
#error C++ is required
#endif

#include <yatengine.h>

namespace TelEngine {

struct YATE_API ImageInfo {
    int width;

    int height;

    int depth;
};

struct YATE_API FormatInfo {
    const char* name;

    const char* type;

    int frameSize;

    int frameTime;

    int sampleRate;

    int numChannels;

    bool converter;

    int guessSamples(int len) const;

    int dataRate() const;

    inline FormatInfo()
        : name(0), type("audio"),
          frameSize(0), frameTime(0),
          sampleRate(8000), numChannels(1),
          converter(false)
        { }

    inline explicit FormatInfo(const char* _name, int fsize = 0, int ftime = 10000,
        const char* _type = "audio", int srate = 8000, int nchan = 1, bool convert = false)
        : name(_name), type(_type),
          frameSize(fsize), frameTime(ftime),
          sampleRate(srate), numChannels(nchan),
          converter(convert)
        { }
};

class DataEndpoint;
class CallEndpoint;
class Driver;

struct YATE_API TranslatorCaps {
    const FormatInfo* src;
    const FormatInfo* dest;
    int cost;
};

class YATE_API FormatRepository
{
    YNOCOPY(FormatRepository); // no automatic copies please
private:
    FormatRepository();
public:
    static const FormatInfo* getFormat(const String& name);

    static const FormatInfo* addFormat(const String& name, int fsize, int ftime, const String& type = "audio", int srate = 8000, int nchan = 1);
};

class YATE_API DataFormat : public NamedList
{
public:
    inline DataFormat()
        : NamedList((const char*)0), m_parsed(0)
        { }

    inline DataFormat(const char* value)
        : NamedList(value), m_parsed(0)
        { }

    inline DataFormat(const DataFormat& value)
        : NamedList(value), m_parsed(value.getInfo())
        { }

    inline DataFormat(const String& value)
        : NamedList(value), m_parsed(0)
        { }

    inline DataFormat(const NamedList& value)
        : NamedList(value), m_parsed(0)
        { }

    inline DataFormat(const String* value)
        : NamedList(value ? value->c_str() : (const char*)0), m_parsed(0)
        { }

    inline explicit DataFormat(const FormatInfo* format)
        : NamedList(format ? format->name : (const char*)0), m_parsed(format)
        { }

    inline DataFormat& operator=(const DataFormat& value)
        { NamedList::operator=(value); m_parsed = value.getInfo(); return *this; }

    const FormatInfo* getInfo() const;

    inline int frameSize(int defValue = 0) const
        { return getInfo() ? getInfo()->frameSize : defValue; }

    inline int frameTime(int defValue = 0) const
        { return getInfo() ? getInfo()->frameTime : defValue; }

    inline int sampleRate(int defValue = 0) const
        { return getInfo() ? getInfo()->sampleRate : defValue; }

    inline int numChannels(int defValue = 1) const
        { return getInfo() ? getInfo()->numChannels : defValue; }

protected:
    virtual void changed();

private:
    mutable const FormatInfo* m_parsed;
};

class YATE_API DataNode : public RefObject
{
    friend class DataEndpoint;
    YNOCOPY(DataNode); // no automatic copies please
public:
    enum DataFlags {
        DataStart   = 0x0001,
        DataEnd     = 0x0002,
        DataMark    = 0x0004,
        DataSilent  = 0x0008,
        DataMissed  = 0x0010,
        DataError   = 0x0020,
        DataPrivate = 0x0100
    };

    inline explicit DataNode(const char* format = 0)
        : m_format(format), m_timestamp(0)
        { }

    virtual int costFormat(const DataFormat& format)
        { return -1; }

    virtual bool setFormat(const DataFormat& format)
        { return false; }

    inline const DataFormat& getFormat() const
        { return m_format; }

    inline unsigned long timeStamp() const
        { return m_timestamp; }

    virtual bool valid() const
        { return true; }

    virtual bool control(NamedList& params)
        { return false; }

    inline static unsigned long invalidStamp()
        { return (unsigned long)-1; }

    virtual void attached(bool added)
        { }

protected:
    DataFormat m_format;
    unsigned long m_timestamp;
};

class DataSource;
class DataTranslator;
class TranslatorFactory;
class ThreadedSourcePrivate;

class YATE_API DataConsumer : public DataNode
{
    friend class DataSource;

public:
    inline explicit DataConsumer(const char* format = "slin")
        : DataNode(format),
          m_source(0), m_override(0),
          m_regularTsDelta(0), m_overrideTsDelta(0), m_lastTsTime(0)
        { }

    virtual void destroyed();

    virtual void* getObject(const String& name) const;

    virtual unsigned long Consume(const DataBlock& data, unsigned long tStamp, unsigned long flags) = 0;

    inline DataSource* getConnSource() const
        { return m_source; }

    inline DataSource* getOverSource() const
        { return m_override; }

    virtual DataSource* getTransSource() const
        { return 0; }

protected:
    virtual bool synchronize(DataSource* source);

private:
    unsigned long Consume(const DataBlock& data, unsigned long tStamp,
        unsigned long flags, DataSource* source);
    DataSource* m_source;
    DataSource* m_override;
    long m_regularTsDelta;
    long m_overrideTsDelta;
    u_int64_t m_lastTsTime;
};

class YATE_API DataSource : public DataNode, public Mutex
{
    friend class DataTranslator;
    YNOCOPY(DataSource); // no automatic copies please
public:
    inline explicit DataSource(const char* format = "slin")
        : DataNode(format), Mutex(false,"DataSource"),
          m_nextStamp(invalidStamp()), m_translator(0) { }

    virtual void destroyed();

    virtual void* getObject(const String& name) const;

    virtual bool valid() const;

    virtual bool control(NamedList& params);

    unsigned long Forward(const DataBlock& data, unsigned long tStamp = invalidStamp(),
        unsigned long flags = 0);

    bool attach(DataConsumer* consumer, bool override = false);

    bool detach(DataConsumer* consumer);

    void clear();

    inline DataTranslator* getTranslator() const
        { return m_translator; }

    void synchronize(unsigned long tStamp);

    inline unsigned long nextStamp() const
        { return m_nextStamp; }

protected:
    unsigned long m_nextStamp;
    ObjList m_consumers;
private:
    inline void setTranslator(DataTranslator* translator) {
            Lock mylock(this);
            m_translator = translator;
        }
    bool detachInternal(DataConsumer* consumer);
    DataTranslator* m_translator;
};

class YATE_API ThreadedSource : public DataSource
{
    friend class ThreadedSourcePrivate;
public:
    virtual void destroyed();

    bool start(const char* name = "ThreadedSource", Thread::Priority prio = Thread::Normal);

    void stop();

    Thread* thread() const;

    bool running() const;

protected:
    inline explicit ThreadedSource(const char* format = "slin")
        : DataSource(format), m_thread(0)
        { }

    virtual void run() = 0;

    virtual void cleanup();

    bool looping(bool runConsumers = false) const;

private:
    ThreadedSourcePrivate* m_thread;
};

class YATE_API DataTranslator : public DataConsumer
{
    friend class TranslatorFactory;
public:
    DataTranslator(const char* sFormat, const char* dFormat);

    explicit DataTranslator(const char* sFormat, DataSource* source = 0);

    ~DataTranslator();

    virtual void* getObject(const String& name) const;

    virtual bool valid() const
        { return m_tsource && m_tsource->valid(); }

    virtual DataSource* getTransSource() const
        { return m_tsource; }

    DataTranslator* getFirstTranslator();

    const DataTranslator* getFirstTranslator() const;

    static ObjList* srcFormats(const DataFormat& dFormat = "slin", int maxCost = -1, unsigned int maxLen = 0, ObjList* lst = 0);

    static ObjList* destFormats(const DataFormat& sFormat = "slin", int maxCost = -1, unsigned int maxLen = 0, ObjList* lst = 0);

    static ObjList* allFormats(const ObjList* formats, bool existing = true, bool sameRate = true, bool sameChans = true);

    static ObjList* allFormats(const String& formats, bool existing = true, bool sameRate = true, bool sameChans = true);

    static bool canConvert(const DataFormat& fmt1, const DataFormat& fmt2 = "slin");

    static int cost(const DataFormat& sFormat, const DataFormat& dFormat);

    static DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat);

    static bool attachChain(DataSource* source, DataConsumer* consumer, bool override = false);

    static bool detachChain(DataSource* source, DataConsumer* consumer);

    static void setMaxChain(unsigned int maxChain);

protected:
    inline ObjList* getConsumers() const
        { return m_tsource ? m_tsource->m_consumers.skipNull() : 0; }

    virtual bool synchronize(DataSource* source);

    static void install(TranslatorFactory* factory);

    static void uninstall(TranslatorFactory* factory);

private:
    DataTranslator(); // No default constructor please
    static void compose();
    static void compose(TranslatorFactory* factory);
    static bool canConvert(const FormatInfo* fmt1, const FormatInfo* fmt2);
    DataSource* m_tsource;
    static Mutex s_mutex;
    static ObjList s_factories;
    static unsigned int s_maxChain;
};

class YATE_API TranslatorFactory : public GenObject
{
    YNOCOPY(TranslatorFactory); // no automatic copies please
protected:
    inline explicit TranslatorFactory(const char* name = 0)
        : m_name(name ? name : "?")
        { m_counter = Thread::getCurrentObjCounter(true); DataTranslator::install(this); }

public:
    virtual ~TranslatorFactory();

    virtual void removed(const TranslatorFactory* factory);

    virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat) = 0;

    virtual const TranslatorCaps* getCapabilities() const = 0;

    virtual bool converts(const DataFormat& sFormat, const DataFormat& dFormat) const;

    virtual unsigned int length() const;

    virtual bool intermediate(const FormatInfo* info) const;

    virtual const FormatInfo* intermediate() const;

    virtual const char* name() const
        { return m_name; }

    inline NamedCounter* objectsCounter() const
        { return m_counter; }

private:
    const char* m_name;
    NamedCounter* m_counter;
};

class YATE_API DataEndpoint : public RefObject
{
    YNOCOPY(DataEndpoint); // no automatic copies please
public:
    explicit DataEndpoint(CallEndpoint* call = 0, const char* name = "audio");

    virtual void destroyed();

    virtual void* getObject(const String& name) const;

    virtual const String& toString() const;

    Mutex* mutex() const;

    static Mutex& commonMutex();

    bool connect(DataEndpoint* peer);

    bool disconnect();

    void setSource(DataSource* source = 0);

    inline DataSource* getSource() const
        { return m_source; }

    void setConsumer(DataConsumer* consumer = 0);

    inline DataConsumer* getConsumer() const
        { return m_consumer; }

    void setPeerRecord(DataConsumer* consumer = 0);

    inline DataConsumer* getPeerRecord() const
        { return m_peerRecord; }

    void setCallRecord(DataConsumer* consumer = 0);

    inline DataConsumer* getCallRecord() const
        { return m_callRecord; }

    bool clearData(DataNode* node);

    bool addSniffer(DataConsumer* sniffer);

    bool delSniffer(DataConsumer* sniffer);

    DataConsumer* getSniffer(const String& name, bool ref = false);

    void clearSniffers();

    inline DataEndpoint* getPeer() const
        { return m_peer; }

    inline CallEndpoint* getCall() const
        { return m_call; }

    inline const String& name() const
        { return m_name; }

    inline void clearCall(const CallEndpoint* call)
        { if (call == m_call) m_call = 0; }

    virtual bool control(NamedList& params);

protected:
    virtual bool nativeConnect(DataEndpoint* peer)
        { return false; }

private:
    String m_name;
    DataSource* m_source;
    DataConsumer* m_consumer;
    DataEndpoint* m_peer;
    CallEndpoint* m_call;
    DataConsumer* m_peerRecord;
    DataConsumer* m_callRecord;
    ObjList m_sniffers;
};

class YATE_API CallEndpoint : public RefObject
{
    friend class DataEndpoint;
    YNOCOPY(CallEndpoint); // no automatic copies please
private:
    CallEndpoint* m_peer;
    const void* m_lastPeer;
    String m_id;
    String m_lastPeerId;

protected:
    ObjList m_data;
    Mutex* m_mutex;

public:
    virtual void destroyed();

    virtual void* getObject(const String& name) const;

    virtual const String& toString() const
        { return m_id; }

    inline const String& id() const
        { return m_id; }

    inline CallEndpoint* getPeer() const
        { return m_peer; }

    bool getPeerId(String& id) const;

    String getPeerId() const;

    bool getLastPeerId(String& id) const;

    void setLastPeerId();

    inline Mutex* mutex() const
        { return m_mutex; }

    static Mutex& commonMutex();

    bool connect(CallEndpoint* peer, const char* reason = 0, bool notify = true);

    inline bool disconnect(const char* reason = 0, bool notify = true, const NamedList* params = 0)
        { return disconnect(false,reason,notify,params); }

    inline bool disconnect(const char* reason, const NamedList& params)
        { return disconnect(false,reason,true,&params); }

    DataEndpoint* getEndpoint(const String& type = CallEndpoint::audioType()) const;

    DataEndpoint* setEndpoint(const String& type = CallEndpoint::audioType());

    void clearEndpoint(const String& type = String::empty());

    void setSource(DataSource* source = 0, const String& type = CallEndpoint::audioType());

    DataSource* getSource(const String& type = CallEndpoint::audioType()) const;

    void setConsumer(DataConsumer* consumer = 0, const String& type = CallEndpoint::audioType());

    DataConsumer* getConsumer(const String& type = CallEndpoint::audioType()) const;

    bool clearData(DataNode* node, const String& type = CallEndpoint::audioType());

    static const String& audioType();

protected:
    CallEndpoint(const char* id = 0);

    virtual void connected(const char* reason) { }

    virtual void disconnected(bool final, const char* reason) { }

    virtual void setDisconnect(const NamedList* params) { }

    void setPeer(CallEndpoint* peer, const char* reason = 0, bool notify = true, const NamedList* params = 0);

    void setEndpoint(DataEndpoint* endPoint);

    virtual void setId(const char* newId);

private:
    bool disconnect(bool final, const char* reason, bool notify, const NamedList* params);
};

class YATE_API Module : public Plugin, public Mutex, public MessageReceiver
{
    YNOCOPY(Module); // no automatic copies please
private:
    bool m_init;
    int m_relays;
    String m_type;
    Regexp m_filter;
    u_int64_t m_changed;
    static unsigned int s_delay;

public:
    virtual void* getObject(const String& name) const;

    inline const String& type() const
        { return m_type; }

    void changed();

    inline static unsigned int updateDelay()
        { return s_delay; }

    inline static void updateDelay(unsigned int delay)
        { s_delay = delay; }

    inline bool filterInstalled() const
        { return !m_filter.null(); }

    bool filterDebug(const String& item) const;

    static bool itemComplete(String& itemList, const String& item, const String& partWord);

protected:
    enum {
        // Module messages
        Status     = 0x00000001,
        Timer      = 0x00000002,
        Level      = 0x00000004,
        Command    = 0x00000008,
        Help       = 0x00000010,
        Halt       = 0x00000020,
        Route      = 0x00000040,
        Stop       = 0x00000080,
        // Driver messages
        Execute    = 0x00000100,
        Drop       = 0x00000200,
        // Channel messages
        Locate     = 0x00000400,
        Masquerade = 0x00000800,
        Ringing    = 0x00001000,
        Answered   = 0x00002000,
        Tone       = 0x00004000,
        Text       = 0x00008000,
        Progress   = 0x00010000,
        Update     = 0x00020000,
        Transfer   = 0x00040000,
        Control    = 0x00080000,
        // Instant messaging related
        MsgExecute = 0x00100000,
        // Last possible public ID
        PubLast    = 0x0fffffff,
        // Private messages base ID
        Private    = 0x10000000
    } RelayID;

    static const char* messageName(int id);

    static inline int relayId(const char* name)
        { return lookup(name,s_messages); }

    Module(const char* name, const char* type = 0, bool earlyInit = false);

    virtual ~Module();

    virtual void initialize();

    void setup();

    inline bool relayInstalled(int id) const
        { return (id & m_relays) != 0; }

    bool installRelay(int id, unsigned priority = 100);

    bool installRelay(const char* name, unsigned priority = 100);

    bool installRelay(int id, const char* name, unsigned priority = 100);

    bool installRelay(MessageRelay* relay);

    bool uninstallRelay(MessageRelay* relay, bool delRelay = true);

    bool uninstallRelay(int id, bool delRelay = true);

    bool uninstallRelays();

    virtual bool received(Message &msg, int id);

    virtual void genUpdate(Message& msg);

    virtual void msgTimer(Message& msg);

    virtual void msgStatus(Message& msg);

    virtual bool msgRoute(Message& msg);

    virtual bool msgCommand(Message& msg);

    virtual void statusModule(String& str);

    virtual void statusParams(String& str);

    virtual void statusDetail(String& str);

    virtual bool commandExecute(String& retVal, const String& line);

    virtual bool commandComplete(Message& msg, const String& partLine, const String& partWord);

    virtual bool setDebug(Message& msg, const String& target);

private:
    Module(); // no default constructor please
    static TokenDict s_messages[];
    ObjList m_relayList;
};

class YATE_API Channel : public CallEndpoint, public DebugEnabler, public MessageNotifier
{
    friend class Driver;
    friend class Router;
    YNOCOPY(Channel); // no automatic copies please
private:
    NamedList m_parameters;
    Driver* m_driver;
    bool m_outgoing;
    u_int64_t m_timeout;
    u_int64_t m_maxcall;
    u_int64_t m_maxPDD;          // Timeout while waiting for some progress on outgoing calls
    u_int64_t m_dtmfTime;
    unsigned int m_toutAns;
    unsigned int m_dtmfSeq;
    String m_dtmfText;
    String m_dtmfDetected;

protected:
    String m_status;
    String m_address;
    String m_targetid;
    String m_billid;
    bool m_answered;

public:
    virtual ~Channel();

    virtual void* getObject(const String& name) const;

    static Mutex& paramMutex();

    virtual void complete(Message& msg, bool minimal = false) const;

    Message* message(const char* name, bool minimal = false, bool data = false);

    Message* message(const char* name, const NamedList* original, const char* params = 0, bool minimal = false, bool data = false);

    inline Message* message(const char* name, const NamedList& original, const char* params = 0, bool minimal = false, bool data = false)
        { return message(name,&original,params,minimal,data); }

    virtual bool msgProgress(Message& msg);

    virtual bool msgRinging(Message& msg);

    virtual bool msgAnswered(Message& msg);

    virtual bool msgTone(Message& msg, const char* tone);

    virtual bool msgText(Message& msg, const char* text);

    virtual bool msgDrop(Message& msg, const char* reason);

    virtual bool msgTransfer(Message& msg);

    virtual bool msgUpdate(Message& msg);

    virtual bool msgMasquerade(Message& msg);

    virtual void msgStatus(Message& msg);

    virtual bool msgControl(Message& msg);

    virtual void checkTimers(Message& msg, const Time& tmr);

    virtual bool callPrerouted(Message& msg, bool handled);

    virtual bool callRouted(Message& msg);

    virtual void callAccept(Message& msg);

    virtual void callRejected(const char* error, const char* reason = 0, const Message* msg = 0);

    virtual void callConnect(Message& msg);

    virtual bool setDebug(Message& msg);

    inline const String& status() const
        { return m_status; }

    inline const String& address() const
        { return m_address; }

    inline bool isOutgoing() const
        { return m_outgoing; }

    inline bool isIncoming() const
        { return !m_outgoing; }

    inline bool isAnswered() const
        { return m_answered; }

    const char* direction() const;

    inline Driver* driver() const
        { return m_driver; }

    inline u_int64_t timeout() const
        { return m_timeout; }

    inline void timeout(u_int64_t tout)
        { m_timeout = tout; }

    inline u_int64_t maxcall() const
        { return m_maxcall; }

    inline void maxcall(u_int64_t tout)
        { m_maxcall = tout; }

    inline void setMaxcall(const Message& msg, int defTout = -1)
        { setMaxcall(&msg,defTout); }

    void setMaxcall(const Message* msg, int defTout = -1);

    inline u_int64_t maxPDD() const
        { return m_maxPDD; }

    inline void maxPDD(u_int64_t tout)
        { m_maxPDD = tout; }

    void setMaxPDD(const Message& msg);

    inline const String& targetid() const
        { return m_targetid; }

    inline const String& billid() const
        { return m_billid; }

    void initChan();

    bool startRouter(Message* msg);

    static unsigned int allocId();

    void filterDebug(const String& item);

    inline const NamedList& parameters() const
        { return m_parameters; }

    virtual void dispatched(const Message& msg, bool handled);

protected:
    Channel(Driver* driver, const char* id = 0, bool outgoing = false);

    Channel(Driver& driver, const char* id = 0, bool outgoing = false);

    void cleanup();

    void dropChan();

    virtual void zeroRefs();

    virtual void connected(const char* reason);

    virtual void disconnected(bool final, const char* reason);

    virtual void setDisconnect(const NamedList* params);

    virtual void endDisconnect(const Message& msg, bool handled);

    virtual void setId(const char* newId);

    virtual Message* getDisconnect(const char* reason);

    void status(const char* newstat);

    virtual void statusParams(String& str);

    inline void setOutgoing(bool outgoing = true)
        { m_outgoing = outgoing; }

    bool dtmfSequence(Message& msg);

    bool dtmfEnqueue(Message* msg);

    bool dtmfInband(const char* tone);

    bool toneDetect(const char* sniffer = 0);

    inline NamedList& parameters()
        { return m_parameters; }

private:
    void init();
    Channel(); // no default constructor please
};

class YATE_API Driver : public Module
{
    friend class Router;
    friend class Channel;

private:
    bool m_init;
    bool m_varchan;
    String m_prefix;
    ObjList m_chans;
    int m_routing;
    int m_routed;
    int m_total;
    unsigned int m_nextid;
    int m_timeout;
    int m_maxroute;
    int m_maxchans;
    int m_chanCount;
    bool m_dtmfDups;
    volatile bool m_doExpire;

public:
    virtual void* getObject(const String& name) const;

    inline const String& prefix() const
        { return m_prefix; }

    inline bool varchan() const
        { return m_varchan; }

    inline ObjList& channels()
        { return m_chans; }

    virtual Channel* find(const String& id) const;

    virtual bool isBusy() const;

    virtual void dropAll(Message &msg);

    virtual bool canAccept(bool routers = true);

    virtual bool canRoute();

    unsigned int nextid();

    inline unsigned int lastid() const
        { return m_nextid; }

    inline int timeout() const
        { return m_timeout; }

    inline int routing() const
        { return m_routing; }

    inline int routed() const
        { return m_routed; }

    inline int total() const
        { return m_total; }

    inline int chanCount() const
        { return m_chanCount; }

    inline int maxChans() const
        { return m_maxchans; }

protected:
    Driver(const char* name, const char* type = 0);

    virtual void initialize();

    void setup(const char* prefix = 0, bool minimal = false);

    virtual bool received(Message &msg, int id);

    virtual void genUpdate(Message& msg);

    virtual bool hasLine(const String& line) const;

    virtual bool msgRoute(Message& msg);

    virtual bool msgExecute(Message& msg, String& dest) = 0;

    virtual bool commandComplete(Message& msg, const String& partLine, const String& partWord);

    virtual void statusModule(String& str);

    virtual void statusParams(String& str);

    virtual void statusDetail(String& str);

    virtual bool setDebug(Message& msg, const String& target);

    virtual void loadLimits();

    inline void varchan(bool variable)
        { m_varchan = variable; }

    inline void timeout(int tout)
        { m_timeout = tout; }

    inline void maxRoute(int ncalls)
        { m_maxroute = ncalls; }

    inline void maxChans(int ncalls)
        { m_maxchans = ncalls; }

    inline void dtmfDups(bool duplicates)
        { m_dtmfDups = duplicates; }

private:
    Driver(); // no default constructor please
};

class YATE_API Router : public Thread
{
    YNOCOPY(Router); // no automatic copies please
private:
    Driver* m_driver;
    String m_id;
    Message* m_msg;

public:
    Router(Driver* driver, const char* id, Message* msg);

    virtual void run();

    virtual bool route();

    virtual void cleanup();

protected:
    const String& id() const
        { return m_id; }
};

class YATE_API CallAccount
{
    YNOCOPY(CallAccount);
private:
    Mutex* m_mutex;
    NamedList m_inbParams;
    NamedList m_outParams;
    NamedList m_regParams;

public:
    void pickAccountParams(const NamedList& params);


    void setInboundParams(NamedList& params);

    void setOutboundParams(NamedList& params);

    void setRegisterParams(NamedList& params);

    inline const NamedList& inboundParams() const
        { return m_inbParams; }

    inline const NamedList& outboundParams() const
        { return m_outParams; }

    inline const NamedList& registerParams() const
        { return m_regParams; }

protected:
    inline CallAccount(Mutex* mutex)
        : m_mutex(mutex), m_inbParams(""), m_outParams(""), m_regParams("")
        { }
};

YATE_API bool isE164(const char* str);

}; // namespace TelEngine

#endif /* __YATEPHONE_H */

/* vi: set ts=8 sw=4 sts=4 noet: */