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): ______________________________________.
 *
 * $Revision: 20867 $
 * $Author: dsandras $
 * $Date: 2008-09-05 11:11:56 +0000 (Fri, 05 Sep 2008) $
 */

#ifndef __OPAL_MANAGER_H
#define __OPAL_MANAGER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <opal/call.h>
#include <opal/connection.h> //OpalConnection::AnswerCallResponse
#include <opal/guid.h>
#include <opal/audiorecord.h>
#include <codec/silencedetect.h>
#include <codec/echocancel.h>
#include <ptclib/pstun.h>

#if OPAL_VIDEO
#include <ptlib/videoio.h>
#endif

class OpalEndPoint;
class OpalMediaPatch;

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
    );

    PList<OpalEndPoint> GetEndPoints() const;

    void ShutDownEndpoints();

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

    virtual void OnEstablishedCall(
      OpalCall & call   
    );

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

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


    virtual PBoolean IsCallEstablished(
      const PString & token  
    );

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

    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 = PTrue   
    );

    virtual void OnClearedCall(
      OpalCall & call   
    );

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

    virtual void DestroyCall(
      OpalCall * call
    );

    PString GetNextCallToken();

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

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

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

    virtual void OnAlerting(
      OpalConnection & connection   
    );

    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 void AdjustMediaFormats(
      const OpalConnection & connection,  
      OpalMediaFormatList & mediaFormats  
    ) const;

    virtual PBoolean IsMediaBypassPossible(
      const OpalConnection & source,      
      const OpalConnection & destination, 
      unsigned sessionID                  
    ) const;

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

    virtual void OnRTPStatistics(
      const OpalConnection & connection,  
      const RTP_Session & session         
    );

    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

#if OPAL_VIDEO

    virtual void AddVideoMediaFormats(
      OpalMediaFormatList & mediaFormats, 
      const OpalConnection * connection = NULL  
    ) const;

    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                     
    );
#endif

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

    virtual void DestroyMediaPatch(
      OpalMediaPatch * patch
    );

    virtual PBoolean OnStartMediaPatch(
      const OpalMediaPatch & patch     
    );

    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 = "#\r\n", 
      unsigned lastDigitTimeout = 4,      
      unsigned firstDigitTimeout = 30     
    );

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

    virtual void OnMWIReceived(
      const PString & party,    
      MessageWaitingType type,  
      const PString & extraInfo 
    );
    
    
    class RouteEntry : public PObject
    {
        PCLASSINFO(RouteEntry, PObject);
      public:
        RouteEntry(const PString & pat, const PString & dest);
        void PrintOn(ostream & strm) const;
        PString            pattern;
        PString            destination;
        PRegularExpression regex;
    };
    PARRAY(RouteTable, RouteEntry);

    virtual PBoolean AddRouteEntry(
      const PString & spec  
    );

    PBoolean SetRouteTable(
      const PStringArray & specs  
    );

    void SetRouteTable(
      const RouteTable & table  
    );

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

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

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

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

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

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

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

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

#if OPAL_VIDEO

    PBoolean CanAutoStartReceiveVideo() const { return autoStartReceiveVideo; }

    void SetAutoStartReceiveVideo(PBoolean can) { autoStartReceiveVideo = can; }

    PBoolean CanAutoStartTransmitVideo() const { return autoStartTransmitVideo; }

    void SetAutoStartTransmitVideo(PBoolean can) { autoStartTransmitVideo = can; }

#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
    );

    const PString & GetTranslationHost() const { return translationHost; }

    bool SetTranslationHost(
      const PString & host
    );

    const PIPSocket::Address & GetTranslationAddress() const { return translationAddress; }

    void SetTranslationAddress(
      const PIPSocket::Address & address
    );

    virtual PNatMethod * GetNatMethod(
      const PIPSocket::Address & remoteAddress = PIPSocket::GetDefaultIpAny()
    ) const;

    PSTUNClient::NatTypes SetSTUNServer(
      const PString & server
    );

    const PString & GetSTUNServer() const { return stunServer; }

    PSTUNClient * GetSTUNClient() const { return stun; }

    WORD GetTCPPortBase() const { return tcpPorts.base; }

    WORD GetTCPPortMax() const { return tcpPorts.max; }

    void SetTCPPorts(unsigned tcpBase, unsigned tcpMax);

    WORD GetNextTCPPort();

    WORD GetUDPPortBase() const { return udpPorts.base; }

    WORD GetUDPPortMax() const { return udpPorts.max; }

    void SetUDPPorts(unsigned udpBase, unsigned udpMax);

    WORD GetNextUDPPort();

    WORD GetRtpIpPortBase() const { return rtpIpPorts.base; }

    WORD GetRtpIpPortMax() const { return rtpIpPorts.max; }

    void SetRtpIpPorts(unsigned udpBase, unsigned udpMax);

    WORD GetRtpIpPortPair();

    BYTE GetRtpIpTypeofService() const { return rtpIpTypeofService; }

    void SetRtpIpTypeofService(unsigned tos) { rtpIpTypeofService = (BYTE)tos; }

    PINDEX GetMaxRtpPayloadSize() const { return rtpPayloadSizeMax; }

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

    unsigned GetMinAudioJitterDelay() const { return minAudioJitterDelay; }

    unsigned GetMaxAudioJitterDelay() const { return maxAudioJitterDelay; }

    void SetAudioJitterDelay(
      unsigned minDelay,   
      unsigned maxDelay    
    );

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

    void SetMediaFormatOrder(
      const PStringArray & order   
    );

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

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

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

    const OpalSilenceDetector::Params & GetSilenceDetectParams() const { return silenceDetectParams; }
    
    virtual void SetEchoCancelParams(
      const OpalEchoCanceler::Params & params
    ) { echoCancelParams = params; }

    const OpalEchoCanceler::Params & GetEchoCancelParams() const { return echoCancelParams; }

#if OPAL_VIDEO

    virtual PBoolean SetVideoInputDevice(
      const PVideoDevice::OpenArgs & deviceArgs 
    );

    const PVideoDevice::OpenArgs & GetVideoInputDevice() const { return videoInputDevice; }

    virtual PBoolean SetVideoPreviewDevice(
      const PVideoDevice::OpenArgs & deviceArgs 
    );

    const PVideoDevice::OpenArgs & GetVideoPreviewDevice() const { return videoPreviewDevice; }

    virtual PBoolean SetVideoOutputDevice(
      const PVideoDevice::OpenArgs & deviceArgs 
    );

    const PVideoDevice::OpenArgs & GetVideoOutputDevice() const { return videoOutputDevice; }

#endif

    PBoolean DetectInBandDTMFDisabled() const
      { return disableDetectInBandDTMF; }

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

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

    PBoolean SetNoMediaTimeout(
      const PTimeInterval & newInterval  
    );

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

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

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

    virtual void OnNewConnection(
      OpalConnection & connection   
    );

    virtual void SetDefaultSecurityMode(const PString & v)
    { defaultSecurityMode = v; }

    virtual PString GetDefaultSecurityMode() const 
    { return defaultSecurityMode; }

    virtual PBoolean UseRTPAggregation() const;

    OpalRecordManager & GetRecordManager()
    { return recordManager; }

    virtual PBoolean StartRecording(const PString & callToken, const PFilePath & fn);
    virtual bool IsRecording(const PString & callToken);
    virtual void StopRecording(const PString & callToken);

  protected:
    // Configuration variables
    OpalProductInfo productInfo;

    PString       defaultUserName;
    PString       defaultDisplayName;

#if OPAL_VIDEO
    PBoolean          autoStartReceiveVideo;
    PBoolean          autoStartTransmitVideo;
#endif

    BYTE          rtpIpTypeofService;
    PINDEX        rtpPayloadSizeMax;
    unsigned      minAudioJitterDelay;
    unsigned      maxAudioJitterDelay;
    PStringArray  mediaFormatOrder;
    PStringArray  mediaFormatMask;
    PBoolean          disableDetectInBandDTMF;
    PTimeInterval noMediaTimeout;
    PString       ilsServer;

    OpalSilenceDetector::Params silenceDetectParams;
    OpalEchoCanceler::Params echoCancelParams;

#if OPAL_VIDEO
    PVideoDevice::OpenArgs videoInputDevice;
    PVideoDevice::OpenArgs videoPreviewDevice;
    PVideoDevice::OpenArgs videoOutputDevice;
#endif

    struct PortInfo {
      void Set(
        unsigned base,
        unsigned max,
        unsigned range,
        unsigned dflt
      );
      WORD GetNext(
        unsigned increment
      );

      PMutex mutex;
      WORD   base;
      WORD   max;
      WORD   current;
    } tcpPorts, udpPorts, rtpIpPorts;
    
    class InterfaceMonitor : public PInterfaceMonitorClient
    {
      PCLASSINFO(InterfaceMonitor, PInterfaceMonitorClient);
      
      enum {
        OpalManagerInterfaceMonitorClientPriority = 100,
      };
      public:
        InterfaceMonitor(OpalManager & manager);
        
      protected:
        virtual void OnAddInterface(const PIPSocket::InterfaceEntry & entry);
        virtual void OnRemoveInterface(const PIPSocket::InterfaceEntry & entry);
        
        OpalManager & m_manager;
    };

    PString            translationHost;
    PIPSocket::Address translationAddress;
    PString            stunServer;
    PSTUNClient      * stun;
    InterfaceMonitor * interfaceMonitor;

    RouteTable routeTable;
    PMutex     routeTableMutex;

    // Dynamic variables
    PReadWriteMutex     endpointsMutex;
    PList<OpalEndPoint> endpointList;
    std::map<PString, OpalEndPoint *> endpointMap;

    PAtomicInteger lastCallTokenID;

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

    PBoolean     clearingAllCalls;
    PSyncPoint   allCallsCleared;
    PThread    * garbageCollector;
    PSyncPoint   garbageCollectExit;
    PDECLARE_NOTIFIER(PThread, OpalManager, GarbageMain);

    PString defaultSecurityMode;

#if OPAL_RTP_AGGREGATE
    PBoolean useRTPAggregation; 
#endif

    OpalRecordManager recordManager;

    friend OpalCall::OpalCall(OpalManager & mgr);
    friend void OpalCall::OnReleased(OpalConnection & connection);
};


PString  OpalGetVersion();
unsigned OpalGetMajorVersion();
unsigned OpalGetMinorVersion();
unsigned OpalGetBuildNumber();


#endif // __OPAL_MANAGER_H


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

---