manager.h

Go to the documentation of this file.

/*
 * manager.h
 *
 * OPAL system manager.
 *
 * Open Phone Abstraction Library (OPAL)
 * Formally known as the Open H323 project.
 *
 * Copyright (c) 2001 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 */

#ifndef OPAL_OPAL_MANAGER_H
#define OPAL_OPAL_MANAGER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#include <opal/pres_ent.h>
#include <opal/call.h>
#include <opal/connection.h> //OpalConnection::AnswerCallResponse
#include <opal/guid.h>
#include <codec/silencedetect.h>
#include <codec/echocancel.h>
#include <im/im.h>

#include <ptclib/pstun.h>
#include <ptclib/url.h>
#include <ptclib/pxml.h>
#include <ptclib/threadpool.h>

#if OPAL_VIDEO
// Inside #if so does not force loading of factories when statically linked.
#include <ptlib/videoio.h>
#endif


class OpalEndPoint;
class OpalMediaPatch;
class OpalLocalConnection;
class PSSLCertificate;
class PSSLPrivateKey;


#define OPAL_SCRIPT_CALL_TABLE_NAME "OpalCall"


class OpalConferenceState : public PObject
{
  PCLASSINFO(OpalConferenceState, PObject);
public:
  OpalConferenceState()
    : m_active(true)
    , m_locked(false)
    , m_maxUsers(0)
  { }

  enum ChangeType {
    Created,
    Destroyed,
    UserAdded,
    UserRemoved,
    NumChangeTypes
  };
  friend ostream & operator<<(ostream & strm, ChangeType type);

  PString  m_internalURI;         

  PString  m_displayText;         
  PString  m_subject;             
  PString  m_notes;               
  PString  m_keywords;            
  bool     m_active;              
  bool     m_locked;              

  struct URI
  {
    PString m_uri;                
    PString m_displayText;        
    PString m_purpose;            
  };
  typedef std::vector<URI> URIs;

  URIs m_accessURI;               
  URIs m_serviceURI;              
  unsigned m_maxUsers;            

  struct User
  {
    PString    m_uri;             
    PString    m_displayText;     
    PStringSet m_roles;           
  };
  typedef std::vector<User> Users;
  Users m_users;

#if P_EXPAT

  PXML m_xml;
#endif
};

typedef std::list<OpalConferenceState> OpalConferenceStates;


class OpalManager : public PObject
{
    PCLASSINFO(OpalManager, PObject);
  public:
    OpalManager();

    ~OpalManager();

    void AttachEndPoint(
      OpalEndPoint * endpoint,    
      const PString & prefix = PString::Empty()  
    );

    void DetachEndPoint(
      const PString & prefix
    );
    void DetachEndPoint(
      OpalEndPoint * endpoint
    );

    OpalEndPoint * FindEndPoint(
      const PString & prefix  
    ) const;

    template <class T> T * FindEndPointAs(
      const PString & prefix  
    ) const { return dynamic_cast<T *>(FindEndPoint(prefix)); }

    PList<OpalEndPoint> GetEndPoints() const;

    PStringList GetPrefixNames(
      const OpalEndPoint * endpoint = NULL  
    ) const;

    virtual PStringList GetNetworkURIs(
      const PString & name
    ) const;

    void ShutDownEndpoints();


#if OPAL_HAS_PRESENCE

    virtual PSafePtr<OpalPresentity> AddPresentity(
      const PString & presentity  
    );

    virtual PSafePtr<OpalPresentity> GetPresentity(
      const PString & presentity,         
      PSafetyMode mode = PSafeReference   
    );

    virtual PStringList GetPresentities() const;

    virtual bool RemovePresentity(
      const PString & presentity  
    );
#endif // OPAL_HAS_PRESENCE


    virtual PSafePtr<OpalCall> SetUpCall(
      const PString & partyA,       
      const PString & partyB,       
      void * userData = NULL,       
      unsigned options = 0,         
      OpalConnection::StringOptions * stringOptions = NULL 
    );
    virtual PBoolean SetUpCall(
      const PString & partyA,       
      const PString & partyB,       
      PString & token,              
      void * userData = NULL,       
      unsigned options = 0,         
      OpalConnection::StringOptions * stringOptions = NULL 
    );

#if OPAL_HAS_MIXER

    virtual bool SetUpConference(
      OpalCall & call,
      const char * mixerURI = NULL,
      const char * localURI = NULL
    );
#endif // OPAL_HAS_MIXER

    virtual PBoolean HasCall(
      const PString & token  
    ) { return m_activeCalls.Find(token, PSafeReference) != NULL; }

    PINDEX GetCallCount() const { return m_activeCalls.GetSize(); }

     PArray<PString> GetAllCalls() const { return m_activeCalls.GetKeys(); }

    PSafePtr<OpalCall> FindCallWithLock(
      const PString & token,  
      PSafetyMode mode = PSafeReadWrite 
    ) const { return m_activeCalls.Find(token, mode); }

    virtual bool OnLocalIncomingCall(
      OpalLocalConnection & connection 
    );

    virtual bool OnLocalOutgoingCall(
      const OpalLocalConnection & connection 
    );

    virtual void OnEstablishedCall(
      OpalCall & call   
    );

    virtual PBoolean IsCallEstablished(
      const PString & token  
    );

    virtual PBoolean ClearCall(
      const PString & token,    
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser, 
      PSyncPoint * sync = NULL  
    );

    virtual PBoolean ClearCallSynchronous(
      const PString & token,    
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser 
    );

    virtual void ClearAllCalls(
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser, 
      PBoolean wait = true   
    );

    virtual void OnClearedCall(
      OpalCall & call   
    );

    virtual OpalCall * CreateCall(
      void * userData            
    );
    OpalCall * InternalCreateCall(void * userData = NULL);

    virtual void DestroyCall(
      OpalCall * call
    );

    virtual PString GetNextToken(char prefix);


    class RouteEntry : public PObject
    {
        PCLASSINFO(RouteEntry, PObject);
      public:
        RouteEntry(const PString & partyA, const PString & partyB, const PString & dest);
        RouteEntry(const PString & spec);

        PObject * Clone() const { return new RouteEntry(*this); }
        void PrintOn(ostream & strm) const;

        bool IsValid() const;
        bool IsMatch(const PString & search) const;

        const PString & GetPartyA() const { return m_partyA; }
        const PString & GetPartyB() const { return m_partyB; }
        const PString & GetDestination() const { return m_destination; }

      protected:
        PString            m_partyA;      
        PString            m_partyB;      
        PString            m_destination; 
        PRegularExpression m_regex;       

        void CompileRegEx();
    };
    PARRAY(RouteTable, RouteEntry);

    virtual PBoolean AddRouteEntry(
      const PString & spec  
    );

    PBoolean SetRouteTable(
      const PStringArray & specs  
    );

    void SetRouteTable(
      const RouteTable & table  
    );

    const RouteTable & GetRouteTable() const { return m_routeTable; }

    virtual PString ApplyRouteTable(
      const PString & source,      
      const PString & destination, 
      PINDEX & entry               
    );

    virtual bool OnRouteConnection(
      PStringSet & routesTried,     
      const PString & a_party,      
      const PString & b_party,      
      OpalCall & call,              
      unsigned options,             
      OpalConnection::StringOptions * stringOptions 
    );


    virtual PSafePtr<OpalConnection> MakeConnection(
      OpalCall & call,                   
      const PString & party,             
      void * userData = NULL,            
      unsigned int options = 0,          
      OpalConnection::StringOptions * stringOptions = NULL 
    );

    virtual void OnNewConnection(
      OpalConnection & connection   
    );

    virtual PBoolean OnIncomingConnection(
      OpalConnection & connection,   
      unsigned options,              
      OpalConnection::StringOptions * stringOptions 
    );

    virtual void OnApplyStringOptions(
      OpalConnection & connection,                  
      OpalConnection::StringOptions & stringOptions 
    );

    virtual void OnProceeding(
      OpalConnection & connection   
    );

    virtual void OnAlerting(
      OpalConnection & connection,   
      bool withMedia                 
    );
    virtual void OnAlerting(OpalConnection & connection); // For backward compatibility

    virtual OpalConnection::AnswerCallResponse OnAnswerCall(
      OpalConnection & connection,    
       const PString & caller         
    );

    virtual void OnConnected(
      OpalConnection & connection   
    );

    virtual void OnEstablished(
      OpalConnection & connection   
    );

    virtual void OnReleased(
      OpalConnection & connection   
    );
    
    virtual void OnHold(
      OpalConnection & connection,   
      bool fromRemote,               
      bool onHold                    
    );
    virtual void OnHold(OpalConnection & connection); // For backward compatibility

    virtual PBoolean OnForwarded(
      OpalConnection & connection,  
      const PString & remoteParty         
    );

    virtual bool OnTransferNotify(
      OpalConnection & connection,  
      const PStringToString & info  
    );


    virtual OpalMediaFormatList GetCommonMediaFormats(
      bool transportable,  
      bool pcmAudio        
    ) const;

    virtual void AdjustMediaFormats(
      bool local,                         
      const OpalConnection & connection,  
      OpalMediaFormatList & mediaFormats  
    ) const;

    P_DECLARE_TRACED_ENUM(MediaTransferMode,
      MediaTransferBypass,   
      MediaTransferForward,  
      MediaTransferTranscode 
    );

    virtual MediaTransferMode GetMediaTransferMode(
      const OpalConnection & provider,    
      const OpalConnection & consumer,    
      const OpalMediaType & mediaType     
    ) const;

    virtual bool GetMediaTransportAddresses(
      const OpalConnection & provider,       
      const OpalConnection & consumer,       
      unsigned sessionId,                    
      const OpalMediaType & mediaType,       
      OpalTransportAddressArray & transports 
    ) const;

    virtual PBoolean OnOpenMediaStream(
      OpalConnection & connection,  
      OpalMediaStream & stream    
    );

    virtual bool OnLocalRTP(
      OpalConnection & connection1, 
      OpalConnection & connection2, 
      unsigned sessionID,           
      bool opened                   
    ) const;

    bool SetMediaPassThrough(
      const PString & token1, 
      const PString & token2, 
      bool bypass,            
      unsigned sessionID = 0, 
      bool network  = true    
    );
    static bool SetMediaPassThrough(
      OpalConnection & connection1, 
      OpalConnection & connection2, 
      bool bypass,                  
      unsigned sessionID = 0        
    );

    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

    virtual void OnFailedMediaStream(
      OpalConnection & connection,  
      bool fromRemote,              
      const PString & reason        
    );

#if OPAL_VIDEO

    virtual PBoolean CreateVideoInputDevice(
      const OpalConnection & connection,    
      const OpalMediaFormat & mediaFormat,  
      PVideoInputDevice * & device,         
      PBoolean & autoDelete                     
    );

    virtual PBoolean CreateVideoOutputDevice(
      const OpalConnection & connection,    
      const OpalMediaFormat & mediaFormat,  
      PBoolean preview,                         
      PVideoOutputDevice * & device,        
      PBoolean & autoDelete                     
    );

    virtual bool CreateVideoInputDevice(
      const OpalConnection & connection,    
      const PVideoDevice::OpenArgs & args,  
      PVideoInputDevice * & device,         
      PBoolean & autoDelete                     
    );

    virtual bool CreateVideoOutputDevice(
      const OpalConnection & connection,    
      const PVideoDevice::OpenArgs & args,  
      PVideoOutputDevice * & device,        
      PBoolean & autoDelete                     
    );
#endif // OPAL_VIDEO

    virtual OpalMediaPatch * CreateMediaPatch(
      OpalMediaStream & source,         
      PBoolean requiresPatchThread = true  
    );

    virtual void OnStartMediaPatch(
      OpalConnection & connection,  
      OpalMediaPatch & patch        
    );

    virtual void OnStopMediaPatch(
      OpalConnection & connection,  
      OpalMediaPatch & patch        
    );

    virtual bool OnMediaFailed(
      OpalConnection & connection,  
      unsigned sessionId            
    );


    virtual void OnUserInputString(
      OpalConnection & connection,  
      const PString & value         
    );

    virtual void OnUserInputTone(
      OpalConnection & connection,  
      char tone,                    
      int duration                  
    );

    virtual PString ReadUserInput(
      OpalConnection & connection,        
      const char * terminators = "YX#\r\n", 
      unsigned lastDigitTimeout = 4,      
      unsigned firstDigitTimeout = 30     
    );


#if OPAL_HAS_MIXER

    virtual PBoolean StartRecording(
      const PString & callToken,  
      const PFilePath & filename, 
      const OpalRecordManager::Options & options = false 
    );

    virtual bool IsRecording(
      const PString & callToken   
    );

    virtual bool StopRecording(
      const PString & callToken   
    );

#endif


#if OPAL_HAS_IM

    virtual void OnConversation(
      const OpalIMContext::ConversationInfo & info 
    );

    virtual PBoolean Message(
      OpalIM & message
    );

    virtual PBoolean Message(
      const PString & to, 
      const PString & body
    );

    virtual PBoolean Message(
      const PURL & to, 
      const PString & type,
      const PString & body,
      PURL & from, 
      PString & conversationId
    );

    virtual void OnMessageReceived(
      const OpalIM & message    
    );

    virtual void OnMessageDisposition(
      const OpalIMContext::DispositionInfo & info    
    );

    virtual void OnCompositionIndication(
      const OpalIMContext::CompositionInfo & info     
    );
#endif


    enum MessageWaitingType { 
      NoMessageWaiting,
      VoiceMessageWaiting, 
      FaxMessageWaiting,
      PagerMessageWaiting,
      MultimediaMessageWaiting,
      TextMessageWaiting,
      NumMessageWaitingTypes
    };

    virtual void OnMWIReceived(
      const PString & party,    
      MessageWaitingType type,  
      const PString & extraInfo 
    );

    virtual bool GetConferenceStates(
      OpalConferenceStates & states,           
      const PString & name = PString::Empty() 
    ) const;

    virtual void OnConferenceStatusChanged(
      OpalEndPoint & endpoint,  
      const PString & uri,      
      OpalConferenceState::ChangeType change 
    );

    virtual bool OnChangedPresentationRole(
      OpalConnection & connection,   
      const PString & newChairURI,   
      bool request                   
    );


#if OPAL_PTLIB_SSL

    virtual bool ApplySSLCredentials(
      const OpalEndPoint & ep,  
      PSSLContext & context,    
      bool create               
    ) const;

    const PString & GetSSLCertificateAuthorityFiles() const { return m_caFiles; }

    void SetSSLCertificateAuthorityFiles(const PString & files) { m_caFiles = files; }

    const PString & GetSSLCertificateFile() const { return m_certificateFile; }

    void SetSSLCertificateFile(const PString & file) { m_certificateFile = file; }

    const PString & GetSSLPrivateKeyFile() const { return m_privateKeyFile; }

    void SetSSLPrivateKeyFile(const PString & file) { m_privateKeyFile = file; }

    void SetSSLAutoCreateCertificate(bool yes) { m_autoCreateCertificate = yes; }

    bool GetSSLAutoCreateCertificate() const { return m_autoCreateCertificate; }
#endif

    virtual PBoolean IsLocalAddress(
      const PIPSocket::Address & remoteAddress
    ) const;

    virtual PBoolean IsRTPNATEnabled(
      OpalConnection & connection,            
      const PIPSocket::Address & localAddr,   
      const PIPSocket::Address & peerAddr,    
      const PIPSocket::Address & signalAddr,  
      PBoolean incoming                       
    );

    virtual PBoolean TranslateIPAddress(
      PIPSocket::Address & localAddress,
      const PIPSocket::Address & remoteAddress
    );

#if OPAL_PTLIB_NAT

    PNatMethods & GetNatMethods() const { return *m_natMethods; }

    bool SetNATServer(
      const PString & method,
      const PString & server,
      bool active = true,
      unsigned priority = 0, // Zero is no change
      const PString & iface = PString::Empty() // Any interface
    );

    PString GetNATServer(
      const PString & method = PString::Empty()
    ) const;

    // Backward compatibility
    void SetTranslationAddress(const PString & addr) { SetNATServer(PNatMethod_Fixed::MethodName(), addr); }
#if P_STUN
    PNatMethod::NatTypes SetSTUNServer(const PString & addr)
        { return SetNATServer(PSTUNClient::MethodName(), addr) ? GetNatMethods().GetMethodByName(PSTUNClient::MethodName())->GetNatType() : PNatMethod::UnknownNat; }
#endif // P_STUN
#endif // OPAL_PTLIB_NAT

    WORD GetTCPPortBase() const { return m_tcpPorts.GetBase(); }

    WORD GetTCPPortMax() const { return m_tcpPorts.GetMax(); }

    void SetTCPPorts(unsigned tcpBase, unsigned tcpMax);

    PIPSocket::PortRange & GetTCPPortRange() { return m_tcpPorts; }
    const PIPSocket::PortRange & GetTCPPortRange() const { return m_tcpPorts; }

    WORD GetUDPPortBase() const { return m_udpPorts.GetBase(); }

    WORD GetUDPPortMax() const { return m_udpPorts.GetMax(); }


    void SetUDPPorts(unsigned udpBase, unsigned udpMax);

    PIPSocket::PortRange & GetUDPPortRange() { return m_udpPorts; }
    const PIPSocket::PortRange & GetUDPPortRange() const { return m_udpPorts; }

    WORD GetRtpIpPortBase() const { return m_rtpIpPorts.GetBase(); }

    WORD GetRtpIpPortMax() const { return m_rtpIpPorts.GetMax(); }

    void SetRtpIpPorts(unsigned udpBase, unsigned udpMax);

    PIPSocket::PortRange & GetRtpIpPortRange() { return m_rtpIpPorts; }
    const PIPSocket::PortRange & GetRtpIpPortRange() const { return m_rtpIpPorts; }

    BYTE GetMediaTypeOfService() const;

    void SetMediaTypeOfService(unsigned tos);

    BYTE GetMediaTypeOfService(const OpalMediaType & type) const;

    void SetMediaTypeOfService(const OpalMediaType & type, unsigned tos);

    const PIPSocket::QoS & GetMediaQoS(const OpalMediaType & type) const;

    void SetMediaQoS(const OpalMediaType & type, const PIPSocket::QoS & qos);

    PINDEX GetMaxRtpPayloadSize() const { return m_rtpPayloadSizeMax; }

    void SetMaxRtpPayloadSize(
      PINDEX size,
      bool mtu = false
    ) { m_rtpPayloadSizeMax = size - (mtu ? (20+16+12) : 0); }

    PINDEX GetMaxRtpPacketSize() const { return m_rtpPacketSizeMax; }

    void SetMaxRtpPacketSize(
      PINDEX size
    ) { m_rtpPacketSizeMax = size; }


    const OpalProductInfo & GetProductInfo() const { return m_productInfo; }

    void SetProductInfo(
      const OpalProductInfo & info, 
      bool updateAll = true         
    );

    const PString & GetDefaultUserName() const { return m_defaultUserName; }

    void SetDefaultUserName(
      const PString & name,   
      bool updateAll = true   
    );

    const PString & GetDefaultDisplayName() const { return m_defaultDisplayName; }

    void SetDefaultDisplayName(
      const PString & name,   
      bool updateAll = true   
    );

    void SetDefaultConnectionOptions(
      const OpalConnection::StringOptions & stringOptions
    ) { m_defaultConnectionOptions = stringOptions; }

#if OPAL_VIDEO

    //
    // these functions are deprecated and used only for backwards compatibility
    // applications should use OpalConnection::GetAutoStart() to check whether
    // a specific media type can be auto-started
    //

    bool CanAutoStartReceiveVideo() const { return (OpalMediaType::Video().GetAutoStart()&OpalMediaType::Receive) != 0; }

    void SetAutoStartReceiveVideo(bool can) { OpalMediaType::Video()->SetAutoStart(OpalMediaType::Receive, can); }

    bool CanAutoStartTransmitVideo() const { return (OpalMediaType::Video().GetAutoStart()&OpalMediaType::Transmit) != 0; }

    void SetAutoStartTransmitVideo(bool can) { OpalMediaType::Video()->SetAutoStart(OpalMediaType::Transmit, can); }

#endif

    const OpalJitterBuffer::Params & GetJitterParameters() const { return m_jitterParams; }

    void SetJitterParameters(const OpalJitterBuffer::Params & params) { m_jitterParams = params; }

    unsigned GetMinAudioJitterDelay() const { return m_jitterParams.m_minJitterDelay; }

    unsigned GetMaxAudioJitterDelay() const { return m_jitterParams.m_maxJitterDelay; }

    void SetAudioJitterDelay(
      unsigned minDelay,   
      unsigned maxDelay    
    );

    const PStringArray & GetMediaFormatOrder() const { return m_mediaFormatOrder; }

    void SetMediaFormatOrder(
      const PStringArray & order   
    );

    const PStringArray & GetMediaFormatMask() const { return m_mediaFormatMask; }

    void SetMediaFormatMask(
      const PStringArray & mask   //< New mask
    );

    virtual void SetSilenceDetectParams(
      const OpalSilenceDetector::Params & params
    ) { m_silenceDetectParams = params; }

    const OpalSilenceDetector::Params & GetSilenceDetectParams() const { return m_silenceDetectParams; }
    
#if OPAL_AEC

    virtual void SetEchoCancelParams(
      const OpalEchoCanceler::Params & params
    ) { m_echoCancelParams = params; }

    const OpalEchoCanceler::Params & GetEchoCancelParams() const { return m_echoCancelParams; }
#endif

#if OPAL_VIDEO

    virtual bool SetVideoInputDevice(
      const PVideoDevice::OpenArgs & deviceArgs, 
      OpalVideoFormat::ContentRole role = OpalVideoFormat::eNoRole  
    );

    const PVideoDevice::OpenArgs & GetVideoInputDevice(
      OpalVideoFormat::ContentRole role = OpalVideoFormat::eNoRole  
    ) const { return m_videoInputDevice[role]; }

    virtual PBoolean SetVideoPreviewDevice(
      const PVideoDevice::OpenArgs & deviceArgs, 
      OpalVideoFormat::ContentRole role = OpalVideoFormat::eNoRole  
    );

    const PVideoDevice::OpenArgs & GetVideoPreviewDevice(
      OpalVideoFormat::ContentRole role = OpalVideoFormat::eNoRole  
    ) const { return m_videoPreviewDevice[role]; }

    virtual PBoolean SetVideoOutputDevice(
      const PVideoDevice::OpenArgs & deviceArgs, 
      OpalVideoFormat::ContentRole role = OpalVideoFormat::eNoRole  
    );

    const PVideoDevice::OpenArgs & GetVideoOutputDevice(
      OpalVideoFormat::ContentRole role = OpalVideoFormat::eNoRole  
    ) const { return m_videoOutputDevice[role]; }

#endif

    PBoolean DetectInBandDTMFDisabled() const
      { return m_disableDetectInBandDTMF; }

    void DisableDetectInBandDTMF(
      PBoolean mode 
    ) { m_disableDetectInBandDTMF = mode; } 

    const PTimeInterval & GetNoMediaTimeout() const { return m_noMediaTimeout; }

    void SetNoMediaTimeout(
      const PTimeInterval & newInterval  
    ) { m_noMediaTimeout = newInterval; }

    const PTimeInterval & GetTxMediaTimeout() const { return m_txMediaTimeout; }

    void SetTxMediaTimeout(
      const PTimeInterval & newInterval  
    ) { m_txMediaTimeout = newInterval; }

    const PTimeInterval & GetSignalingTimeout() const { return m_signalingTimeout; }

    void SetSignalingTimeout(
      const PTimeInterval & newInterval  
    ) { m_signalingTimeout = newInterval; }

    const PTimeInterval & GetTransportIdleTime() const { return m_transportIdleTime; }

    void SetTransportIdleTime(
      const PTimeInterval & newInterval  
    ) { m_transportIdleTime = newInterval; }

    const PTimeInterval & GetNatKeepAliveTime() const { return m_natKeepAliveTime; }

    void SetNatKeepAliveTime(
      const PTimeInterval & newInterval  
    ) { m_natKeepAliveTime = newInterval; }

#if OPAL_ICE

    const PTimeInterval & GetICETimeout() const { return m_iceTimeout; }

    void SetICETimeout(
      const PTimeInterval & newInterval  
    ) { m_iceTimeout = newInterval; }
#endif // OPAL_ICE

    const PTimeInterval & GetStaleReceiverTimeout() const { return m_staleReceiverTimeout; }

    void SetStaleReceiverTimeout(
      const PTimeInterval & newInterval  
    ) { m_staleReceiverTimeout = newInterval; }

#if OPAL_SRTP

    const PTimeInterval & GetDTLSTimeout() const { return m_dtlsTimeout; }

    void SetDTLSTimeout(
      const PTimeInterval & newInterval  
    ) { m_dtlsTimeout = newInterval; }
#endif // OPAL_SRTP

    const PString & GetDefaultILSServer() const { return m_ilsServer; }

    void SetDefaultILSServer(
      const PString & server
    ) { m_ilsServer = server; }

#if OPAL_SCRIPT

    PScriptLanguage * GetScript() const { return m_script; }

    bool RunScript(
      const PString & script,
      const char * language = "Lua"
    );
#endif // OPAL_SCRIPT


    // needs to be public for gcc 3.4
    void GarbageCollection();

    // Decoupled event to avoid deadlocks, especially from patch threads
    void QueueDecoupledEvent(PSafeWork * work, const char * group = NULL) { m_decoupledEventPool.AddWork(work, group); }

    typedef std::map<OpalMediaType, PIPSocket::QoS> MediaQoSMap;

  protected:
    // Configuration variables
    OpalProductInfo m_productInfo;

    PString       m_defaultUserName;
    PString       m_defaultDisplayName;

    mutable MediaQoSMap m_mediaQoS;

    OpalConnection::StringOptions m_defaultConnectionOptions;

    PINDEX        m_rtpPayloadSizeMax;
    PINDEX        m_rtpPacketSizeMax;
    OpalJitterBuffer::Params m_jitterParams;
    PStringArray  m_mediaFormatOrder;
    PStringArray  m_mediaFormatMask;
    bool          m_disableDetectInBandDTMF;
    PTimeInterval m_noMediaTimeout;
    PTimeInterval m_txMediaTimeout;
    PTimeInterval m_signalingTimeout;
    PTimeInterval m_transportIdleTime;
    PTimeInterval m_natKeepAliveTime;
#if OPAL_ICE
    PTimeInterval m_iceTimeout;
#endif
    PTimeInterval m_staleReceiverTimeout;
#if OPAL_SRTP
    PTimeInterval m_dtlsTimeout;
#endif
    PString       m_ilsServer;

    OpalSilenceDetector::Params m_silenceDetectParams;
#if OPAL_AEC
    OpalEchoCanceler::Params m_echoCancelParams;
#endif

#if OPAL_VIDEO
    PVideoDevice::OpenArgs m_videoInputDevice[OpalVideoFormat::NumContentRole];
    PVideoDevice::OpenArgs m_videoPreviewDevice[OpalVideoFormat::NumContentRole];
    PVideoDevice::OpenArgs m_videoOutputDevice[OpalVideoFormat::NumContentRole];
#endif

    PIPSocket::PortRange m_tcpPorts, m_udpPorts, m_rtpIpPorts;
    
#if OPAL_PTLIB_SSL
    PString   m_caFiles;
    PFilePath m_certificateFile;
    PFilePath m_privateKeyFile;
    bool      m_autoCreateCertificate;
#endif

#if OPAL_PTLIB_NAT
    PNatMethods * m_natMethods;
    PDECLARE_InterfaceNotifier(OpalManager, OnInterfaceChange);
    PInterfaceMonitor::Notifier m_onInterfaceChange;
#endif

    RouteTable m_routeTable;
    PDECLARE_MUTEX(m_routeMutex);

    // Dynamic variables
    PDECLARE_READ_WRITE_MUTEX(m_endpointsMutex);
    PList<OpalEndPoint> m_endpointList;
    std::map<PString, OpalEndPoint *> m_endpointMap;

    atomic<unsigned> lastCallTokenID;

    class CallDict : public PSafeDictionary<PString, OpalCall>
    {
      public:
        CallDict(OpalManager & mgr) : manager(mgr) { }
        virtual void DeleteObject(PObject * object) const;
        OpalManager & manager;
    } m_activeCalls;

#if OPAL_HAS_PRESENCE
    PSafeDictionary<PString, OpalPresentity> m_presentities;
#endif // OPAL_HAS_PRESENCE

    atomic<PINDEX> m_clearingAllCallsCount;
    PDECLARE_MUTEX(m_clearingAllCallsMutex);
    PSyncPoint     m_allCallsCleared;
    void InternalClearAllCalls(OpalConnection::CallEndReason reason, bool wait, bool first);

    PThread    * m_garbageCollector;
    PSyncPoint   m_garbageCollectExit;
    PTime        m_garbageCollectChangeTime;
    PDECLARE_NOTIFIER(PThread, OpalManager, GarbageMain);

    friend OpalCall::OpalCall(OpalManager & mgr);
    friend void OpalCall::InternalOnClear();

    PSafeThreadPool m_decoupledEventPool;

#if OPAL_SCRIPT
    PScriptLanguage * m_script;
#endif

  private:
    P_REMOVE_VIRTUAL(OpalCall *,CreateCall(), 0);
    P_REMOVE_VIRTUAL(PBoolean, OnIncomingConnection(OpalConnection &, unsigned), false);
    P_REMOVE_VIRTUAL(PBoolean, OnIncomingConnection(OpalConnection &), false);
    P_REMOVE_VIRTUAL(PBoolean, OnStartMediaPatch(const OpalMediaPatch &), false);
    P_REMOVE_VIRTUAL_VOID(AdjustMediaFormats(const OpalConnection &, OpalMediaFormatList &) const);
    P_REMOVE_VIRTUAL_VOID(OnMessageReceived(const PURL&,const PString&,const PURL&,const PString&,const PString&,const PString&));
    P_REMOVE_VIRTUAL_VOID(OnRTPStatistics(const OpalConnection &, const OpalRTPSession &));
    P_REMOVE_VIRTUAL(PBoolean, IsMediaBypassPossible(const OpalConnection &,const OpalConnection &,unsigned) const, false);
#if OPAL_PTLIB_NAT
    P_REMOVE_VIRTUAL(PNatMethod *, GetNatMethod(const PIPSocket::Address &) const, NULL);
#endif
    P_REMOVE_VIRTUAL(bool,OnLocalIncomingCall(OpalCall &),false);
    P_REMOVE_VIRTUAL(bool,OnLocalOutgoingCall(OpalCall &),false);
    P_REMOVE_VIRTUAL(bool,OnMediaFailed(OpalConnection &,unsigned,bool),false);
};


void OpalGetVersion(PProcess::VersionInfo version);
PString OpalGetVersion();


#endif // OPAL_OPAL_MANAGER_H


// End of File ///////////////////////////////////////////////////////////////