call.h

Go to the documentation of this file.

/*
 * call.h
 *
 * Telephone call management
 *
 * 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: 24763 $
 * $Author: rjongbloed $
 * $Date: 2010-09-29 22:17:02 -0500 (Wed, 29 Sep 2010) $
 */

#ifndef OPAL_OPAL_CALL_H
#define OPAL_OPAL_CALL_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <opal/connection.h>
#include <opal/recording.h>
#include <opal/guid.h>

#include <ptlib/safecoll.h>


class OpalManager;


class OpalCall : public PSafeObject
{
    PCLASSINFO(OpalCall, PSafeObject);
  public:
    OpalCall(
      OpalManager & manager   
    );

    ~OpalCall();

    void PrintOn(
      ostream & strm    
    ) const;

    PBoolean IsEstablished() const { return isEstablished; }

    virtual void OnEstablishedCall();

    OpalConnection::CallEndReason GetCallEndReason() const { return callEndReason; }

    PString GetCallEndReasonText() const { return OpalConnection::GetCallEndReasonText(callEndReason); }

    void SetCallEndReason(
      OpalConnection::CallEndReason reason   
    );

    void Clear(
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser, 
      PSyncPoint * sync = NULL                                                 
    );

    virtual void OnCleared();

    virtual void OnNewConnection(
      OpalConnection & connection   
    );

    virtual PBoolean OnSetUp(
      OpalConnection & connection   
    );

    virtual void OnProceeding(
      OpalConnection & connection   
    );

    virtual PBoolean OnAlerting(
      OpalConnection & connection   
    );

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

    virtual PBoolean OnConnected(
      OpalConnection & connection   
    );

    virtual PBoolean OnEstablished(
      OpalConnection & connection   
    );

    virtual void OnReleased(
      OpalConnection & connection   
    );

    virtual void OnHold(
      OpalConnection & connection,   
      bool fromRemote,               
      bool onHold                    
    );

    PSafePtr<OpalConnection> GetOtherPartyConnection(
      const OpalConnection & connection  
    ) const;

    PSafePtr<OpalConnection> GetConnection(
      PINDEX idx,
      PSafetyMode mode = PSafeReference
    ) { return connectionsActive.GetAt(idx, mode); }

    template <class ConnClass>
    PSafePtr<ConnClass> GetConnectionAs(
      PINDEX count = 0,
      PSafetyMode mode = PSafeReadWrite
    )
    {
      PSafePtr<ConnClass> connection;
      for (PSafePtr<OpalConnection> iterConn(connectionsActive, PSafeReference); iterConn != NULL; ++iterConn) {
        if ((connection = PSafePtrCast<OpalConnection, ConnClass>(iterConn)) != NULL && count-- == 0) {
          if (!connection.SetSafetyMode(mode))
            connection.SetNULL();
          break;
        }
      }
      return connection;
    }

    bool Hold();

    bool Retrieve();

    bool IsOnHold() const;

    bool Transfer(
      const PString & address,           
      OpalConnection * connection = NULL 
    );

    virtual OpalMediaFormatList GetMediaFormats(
      const OpalConnection & connection,  
      PBoolean includeSpecifiedConnection     
    );

    virtual bool OpenSourceMediaStreams(
      OpalConnection & connection,              
      const OpalMediaType & mediaType,          
      unsigned sessionID = 0,                   
      const OpalMediaFormat & preselectedFormat = OpalMediaFormat()  
#if OPAL_VIDEO
      , OpalVideoFormat::ContentRole contentRole = OpalVideoFormat::eNoRole 
#endif
    );

    virtual bool SelectMediaFormats(
      const OpalMediaType & mediaType,        
      const OpalMediaFormatList & srcFormats, 
      const OpalMediaFormatList & dstFormats, 
      const OpalMediaFormatList & allFormats, 
      OpalMediaFormat & srcFormat,            
      OpalMediaFormat & dstFormat             
    ) const;

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

    virtual void StartMediaStreams();

    virtual void CloseMediaStreams();

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

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

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

    OpalManager & GetManager() const { return manager; }

    const PString & GetToken() const { return myToken; }

    const PString & GetPartyA() const { return m_partyA; }

    const PString & GetPartyB() const { return m_partyB; }

    void SetPartyB(
      const PString & b
    ) { m_partyB = b; }

    bool IsNetworkOriginated() const;

    const PTime & GetStartTime() const { return startTime; }

#if OPAL_HAS_MIXER

    bool StartRecording(
      const PFilePath & filename, 
      const OpalRecordManager::Options & options = false 
    );

    bool IsRecording() const;

    void StopRecording();

    virtual bool OnStartRecording(
      const PString & streamId,       
      const OpalMediaFormat & format  
    );

    virtual void OnStopRecording(
      const PString & streamId       
    );

    virtual void OnRecordAudio(
      const PString & streamId,       
      const RTP_DataFrame & frame     
    );

#if OPAL_VIDEO

    virtual void OnRecordVideo(
      const PString & streamId,       
      const RTP_DataFrame & frame     
    );
#endif
#endif // OPAL_HAS_MIXER

    void InternalOnClear();

  protected:
    void SetPartyNames();

    bool EnumerateConnections(
      PSafePtr<OpalConnection> & connection,
      PSafetyMode mode,
      const OpalConnection * skipConnection = NULL
    ) const;

    OpalManager & manager;

    PString myToken;

    PString m_partyA;
    PString m_partyB;
    PTime   startTime;
    bool    isEstablished;
    bool    isClearing;

    OpalConnection::CallEndReason callEndReason;
    PSyncPoint                  * endCallSyncPoint;

    PSafeList<OpalConnection> connectionsActive;

#if OPAL_HAS_MIXER
    OpalRecordManager * m_recordManager;
#endif

  //use to add the connection to the call's connection list
  friend OpalConnection::OpalConnection(OpalCall &, OpalEndPoint &, const PString &, unsigned int, OpalConnection::StringOptions *);
  //use to remove the connection from the call's connection list
  friend OpalConnection::~OpalConnection();
};


#endif // OPAL_OPAL_CALL_H


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

---