ptcalllistener.h

基于sipfoundy 公司开发的sipx协议API

//
// Copyright (C) 2004, 2005 Pingtel Corp.
// 
//
// $$
////////////////////////////////////////////////////////////////////////
//////

#ifndef _PtCallListener_h_
#define _PtCallListener_h_

// SYSTEM INCLUDES
// APPLICATION INCLUDES
#include <os/OsDefs.h>
#include <ptapi/PtEventListener.h>
#include <ptapi/PtMultiCallMetaEvent.h>

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS
class PtCallEvent;

//:The PtCallListener is used to register with PtAddress, PtTerminal, and
//:PtCall objects to receive events from associated PtCall objects.

class PtCallListener : public PtEventListener
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:
   PT_CLASS_INFO_MEMBERS

/* ============================ CREATORS ================================== */

   PtCallListener(PtEventMask* pMask = NULL);
     //:Default constructor
     //!param: (in) pMask - Event mask defining events the listener is interested in.  This must be a subset of the events that the listener supports.  The mask may be NULL where it is assumed that all events applicable to the derived listener are of interest.

   virtual
   ~PtCallListener();
     //:Destructor

/* ============================ MANIPULATORS ============================== */

  virtual void callEventTransmissionEnded(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_EVENT_TRANSMISSION_ENDED
     //:indicating that the application will no longer receive call events on
     //:this instance of the PtCallListener.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callActive(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_ACTIVE
     //:indicating that the state of the call object has changed to
     //:PtCall::ACTIVE.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callInvalid(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_INVALID
     //:indicating that the state of the call object has changed to
     //:PtCall::INVALID.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaCallStartStarted(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_CALL_STARTING_STARTED
     //:indicating that the starting of a new call.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaCallStartEnded(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_CALL_STARTING_ENDED
     //:indicating that the starting of a new call is completed.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaCallEndStarted(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_CALL_ENDING_STARTED
     //:indicating that the starting of dropping a call.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaCallEndEnded(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_CALL_ENDING_ENDED
     //:indicating that the droping of a call is completed.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaProgressStarted(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_PROGRESS_STARTED
     //:indicating that the current call in the telephony platform has changed
     //:state, and events will follow which indicate the changes to this call.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaProgressEnded(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_PROGRESS_ENDED
     //:indicating that the current call in the telephony platform has changed
     //:state, and all the events that were associated with that change have
     //:now been reported.
     // The event parameter is valid only within
     // this method.  The implementation must copy the event if
     // it is needed beyond the scope of an invocation.  The implementation
     // of this method should not block as it may prevent other listeners
     // from processing events in a timely fashion.
     //!param: (in) rEvent - Reference to the PtEvent containing the specific event information.

  virtual void callMetaSnapshotStarted(const PtCallEvent& rEvent);
     //:Method invoked on listener for event id =
     //:CALL_META_SNAPSHOT_STARTED
     //:indicating that the Pingtel implementation is reporting to the
     //:application the current state of the call on the associated telephony
     //:platform, by reporting a set of simulated state changes that, in
     //:effect, construct the current state of the call.
     // The event parameter is valid only within