ptcall.h

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

   virtual PtStatus unhold(UtlBoolean bRemoteParticipants = TRUE) ;
     //:Places the call into focus and takes any held connections off hold.
     //:Optionally remote participants can be taken off hold or left in
     //:their present state.
     //!param (in) bRemoteParticipants - Controls whether all particpants
     //            are taken off hold or not.  If TRUE, all participants
     //            are taken off hold.  If FALSE, only the local connection
     //            is taken off hold  (placed into focus).
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_BUSY - Unable to communicate with call processing

   virtual PtStatus setCodecCPULimit(const int limit,
                                     const UtlBoolean bAutoRenegotiate = TRUE);
      //:Sets the CPU codec limit for this call.
      //!param (in) limit - The codec/CPU limit for this call.  The value can
      //       be set to LOW (0) or HIGH (1).  If set to LOW, only LOW CPU
      //       intensive codecs are allowed.  If set to HIGH, both LOW and
      //       HIGH CPU intensive codes are allowed.
      //!param (in) bAutoRenegotiate - Defines if call call processiong should
      //       automatically force a renegotation of codecs to match the
      //       specified level.
      //!retcode: PT_SUCCESS - Success
      //!retcode: PT_BUSY - Unable to communicate with call processing


   virtual PtStatus forceCodecRenegotiation() ;
      //:Forces the renegotation of all connections for this call.
      //!retcode: PT_SUCCESS - Success
      //!retcode: PT_BUSY - Unable to communicate with call processing



/* ============================ ACCESSORS ================================= */

   virtual PtStatus getCallListeners(PtCallListener* callListeners[], int size,
                             int& rNumItems);
     //:Returns an array of PtCallListener pointers for all of the call
     //:listeners presently associated with this call.
     //!param: (out) callListeners - The array of pointers to known call listeners
     //!param: (in) size - The number of elements in the <i>callListeners</i> array
     //!param: (out) rNumItems - The number of items assigned
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_MORE_DATA - There are more than <i>size</i> listeners
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getCalledAddress(PtAddress& rAddress);
     //:Sets <i>rpAddress</i> to point to the called PtAddress associated
     //:with this call.  This method should only be used for two-party calls.
     // The called PtAddress is the PtAddress to which the call was
     // originally placed.  If the called address is unknown or not yet known,
     // <i>rpAddress</i> will be set to NULL.
     //!param: (out) rAddress - Set to point to the called PtAddress for this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getCallingAddress(PtAddress& rAddress);
     //:Sets <i>rpAddress</i> to point to the calling PtAddress associated
     //:with this call.  This method should only be used for two-party calls.
     // The calling PtAddress is the PtAddress which originally placed the
     // telephone call.  If the calling address is unknown or not yet known,
     // <i>rpAddress</i> will be set to NULL.
     //!param: (out) rAddress - Set to point to the calling PtAddress for this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getCallingTerminal(PtTerminal& rTerminal);
     //:Sets <i>rpTerminal</i> to point to the calling PtTerminal associated
     //:with this call.  This method should only be used for two-party calls.
     // The calling PtTerminal is the PtTerminal which originally placed the
     // telephone call.  If the calling terminal is unknown or not yet known,
     // <i>rpTerminal</i> will be set to NULL.
     //!param: (out) rpTerminal - Set to point to the calling PtTerminal for this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getConferenceController(PtTerminalConnection& rController);
     //:Sets <i>rpController</i> to point to the PtTerminalConnection which
     //:currently acts as the conference controller.
     // The conference controller represents the participant in the telephone
     // system around which a conference takes place.  When a PtCall is
     // initially created, it has no conference controller.  This method sets
     // <i>rpController</i> to non-NULL only if the application has
     // previously set the conference controller.  If the current conference
     // controller leaves the call, the call reverts to not having a
     // conference controller.
     //!param: (out) rpController - Set to point to the conference controller for this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getConnections(PtConnection connections[], int size,
                           int& rNumItems);
     //:Returns an array of pointers to PtConnection objects currently
     //:associated with this call.
     // The caller provides an array that can hold up to <i>size</i>
     // PtConnection pointers.  This method will fill in the
     // <i>connections</i> array with up to <i>size</i> pointers.  The
     // actual number of pointers filled in is passed back via the
     // <i>nItems</i> argument.
     //!param: (out) connections - The array of PtConnection pointers
     //!param: (in) size - The number of elements in the <i>connections</i> array
     //!param: (out) rNumItems - The number of items assigned
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_MORE_DATA - There are more than <i>size</i> connections
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getLastRedirectedAddress(PtAddress& rAddress);
     //:Sets <i>rpAddress</i> to point to the last redirected PtAddress
     //:associated with this call.  This method should only be used for
     //:two-party calls.
     // The last redirected PtAddress is the PtAddress at which this call
     // was placed immediately before the current PtAddress.  This address
     // is of interest when a PtCall is forwarded to a different PtAddress
     // before being answered.  If the last redirected address is unknown
     // or not yet known, <i>rpAddress</i> will be set to NULL.
     //!param: (out) rpAddress - Set to point to the last redirected PtAddress for this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getProvider(PtProvider& rProvider);
     //:Returns a pointer to the PtProvider associated with this call.
     //!param: (out) rpProvider - a pointer to the PtProvider object associated with this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getState(int& rState);
     //:Sets <i>rState</i> to the current state of the telephone call, either
     //:IDLE, ACTIVE or INVALID.
     //!retcode: IDLE - Initial state for a call
     //!retcode: ACTIVITY - Call with one or more connections
     //!retcode: INVALID - Call that is no longer valid (and has zero connections)

   PtStatus getCallId(char* callId, int len);
     //:Sets <i>callId</i> to the current call id.
     //!retcode: IDLE - Initial state for a call
     //!retcode: ACTIVITY - Call with one or more connections
     //!retcode: INVALID - Call that is no longer valid (and has zero connections)

   virtual PtStatus getTransferController(PtTerminalConnection& rController);
     //:Sets <i>rpController</i> to point to the PtTerminalConnection which
     //:currently acts as the transfer controller.
     // The conference controller represents the participant in the telephone
     // system around which a transfer takes place.  When a PtCall is
     // initially created, it has no transfer controller.  This method sets
     // <i>rpController</i> to non-NULL only if the application has
     // previously set the transfer controller.  If the current transfer
     // controller leaves the call, the call reverts to not having a
     // transfer controller.
     //!param: (out) rpController - Set to point to the transfer controller for this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus numConnections(int& rCount);
     //:Returns the number of connections associated with this call.
     //!param: (out) rCount - The number of connections associated with this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus numCallListeners(int& rCount);
     //:Returns the number of call listeners associated with this call.
     //!param: (out) rCount - The number of call listeners associated with this call
     //!retcode: PT_SUCCESS - Success
     //!retcode: PT_PROVIDER_UNAVAILABLE - The provider is not available

   virtual PtStatus getCodecCPUCost(int& cost) ;
      //:Gets the current CPU cost given the negotiated codecs.
      //!param (out) cost - The cpu cost of the currently negotiated and
      //       advertised codes.   A value of zero indicates LOW and 1
      //       indicates HIGH.
      //!retcode: PT_SUCCESS - Success
      //!retcode: PT_BUSY - Unable to communicate with call processing

   virtual  PtStatus getCodecCPULimit(int& cost) ;
      //:Gets the max  CPU cost given the negotiated codecs.
      //!param (out) cost - The cpu cost of the currently negotiated and
      //       advertised codes.   A value of zero indicates LOW and 1
      //       indicates HIGH.
      //!retcode: PT_SUCCESS - Success
      //!retcode: PT_BUSY - Unable to communicate with call processing


/* ============================ INQUIRY =================================== */

friend class PtCallEvent;

/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:
        UtlString       mCallId;
        char    mState;

    static OsBSem           semInit ;
      //: Binary Semaphore used to guard initialiation and tear down
        static TaoReference             *mpTransactionCnt;
        static int                              mRef;

        PtTerminalConnection* mpConfController;
        TaoClientTask   *mpClient;

        OsTime          mTimeOut;

        void    initialize();

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

        OsProtectEventMgr *mpEventMgr;

};

/* ============================ INLINE METHODS ============================ */

#endif  // _PtCall_h_