/*
 * Copyright (C) 2012-2013 Teluu Inc. (http://www.teluu.com)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef __PJSUA2_CALL_HPP__
#define __PJSUA2_CALL_HPP__

/**
 * @file pjsua2/call.hpp
 * @brief PJSUA2 Call manipulation
 */
#include <pjsua-lib/pjsua.h>
#include <pjsua2/account.hpp>
#include <pjsua2/media.hpp>

/** PJSUA2 API is inside pj namespace */
namespace pj
{

/**
 * @defgroup PJSUA2_CALL Call
 * @ingroup PJSUA2_Ref
 */

/**
 * @defgroup PJSUA2_Call_Data_Structure Call Related Types
 * @ingroup PJSUA2_DS
 * @{
 */

using std::string;
using std::vector;

//////////////////////////////////////////////////////////////////////////////

/**
 * Media stream, corresponds to pjmedia_stream
 */
typedef void *MediaStream;

/**
 * Media transport, corresponds to pjmedia_transport
 */
typedef void *MediaTransport;

/**
 * This structure describes statistics state.
 */
struct MathStat
{
    int n;      /**< number of samples  */
    int max;    /**< maximum value      */
    int min;    /**< minimum value      */
    int last;   /**< last value         */
    int mean;   /**< mean               */

public:
    /**
     * Default constructor
     */
    MathStat();
    
    /**
     * Convert from pjsip
     */
    void fromPj(const pj_math_stat &prm);
};

/**
 * Types of loss detected.
 */
struct LossType
{
    unsigned        burst;      /**< Burst/sequential packet lost detected  */
    unsigned        random;     /**< Random packet lost detected.           */
};

/**
 * Unidirectional RTP stream statistics.
 */
struct RtcpStreamStat
{
    TimeVal         update;     /**< Time of last update.                   */
    unsigned        updateCount;/**< Number of updates (to calculate avg)   */
    unsigned        pkt;        /**< Total number of packets                */
    unsigned        bytes;      /**< Total number of payload/bytes          */
    unsigned        discard;    /**< Total number of discarded packets.     */
    unsigned        loss;       /**< Total number of packets lost           */
    unsigned        reorder;    /**< Total number of out of order packets   */
    unsigned        dup;        /**< Total number of duplicates packets     */
    
    MathStat        lossPeriodUsec; /**< Loss period statistics             */

    LossType        lossType;   /**< Types of loss detected.                */
    
    MathStat        jitterUsec; /**< Jitter statistics                      */
    
public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjmedia_rtcp_stream_stat &prm);
};

/**
 * RTCP SDES structure.
 */
struct RtcpSdes
{
    string      cname;          /**< RTCP SDES type CNAME.      */
    string      name;           /**< RTCP SDES type NAME.       */
    string      email;          /**< RTCP SDES type EMAIL.      */
    string      phone;          /**< RTCP SDES type PHONE.      */
    string      loc;            /**< RTCP SDES type LOC.        */
    string      tool;           /**< RTCP SDES type TOOL.       */
    string      note;           /**< RTCP SDES type NOTE.       */

public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjmedia_rtcp_sdes &prm);
};
    
/**
 * Bidirectional RTP stream statistics.
 */
struct RtcpStat
{
    TimeVal             start;          /**< Time when session was created  */
    
    RtcpStreamStat      txStat;         /**< Encoder stream statistics.     */
    RtcpStreamStat      rxStat;         /**< Decoder stream statistics.     */
    
    MathStat            rttUsec;        /**< Round trip delay statistic.    */
    
    pj_uint32_t         rtpTxLastTs;    /**< Last TX RTP timestamp.         */
    pj_uint16_t         rtpTxLastSeq;   /**< Last TX RTP sequence.          */

    MathStat            rxIpdvUsec;     /**< Statistics of IP packet delay
                                             variation in receiving
                                             direction. It is only used when
                                             PJMEDIA_RTCP_STAT_HAS_IPDV is
                                             set to non-zero.               */

    MathStat            rxRawJitterUsec;/**< Statistic of raw jitter in
                                             receiving direction. It is only 
                                             used when
                                             PJMEDIA_RTCP_STAT_HAS_RAW_JITTER
                                             is set to non-zero.            */
    
    RtcpSdes            peerSdes;       /**< Peer SDES.                     */

public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjmedia_rtcp_stat &prm);
};

/**
 * This structure describes jitter buffer state.
 */
struct JbufState
{
    /* Setting */
    unsigned    frameSize;          /**< Individual frame size, in bytes.   */
    unsigned    minPrefetch;        /**< Minimum allowed prefetch, in frms. */
    unsigned    maxPrefetch;        /**< Maximum allowed prefetch, in frms. */
    
    /* Status */
    unsigned    burst;              /**< Current burst level, in frames     */
    unsigned    prefetch;           /**< Current prefetch value, in frames  */
    unsigned    size;               /**< Current buffer size, in frames.    */
    
    /* Statistic */
    unsigned    avgDelayMsec;       /**< Average delay, in ms.              */
    unsigned    minDelayMsec;       /**< Minimum delay, in ms.              */
    unsigned    maxDelayMsec;       /**< Maximum delay, in ms.              */
    unsigned    devDelayMsec;       /**< Standard deviation of delay, in ms.*/
    unsigned    avgBurst;           /**< Average burst, in frames.          */
    unsigned    lost;               /**< Number of lost frames.             */
    unsigned    discard;            /**< Number of discarded frames.        */
    unsigned    empty;              /**< Number of empty on GET events.     */
    
public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjmedia_jb_state &prm);
};

/**
 * This structure describes SDP session description. It corresponds to the
 * pjmedia_sdp_session structure.
 */
struct SdpSession
{
    /**
     * The whole SDP as a string.
     */
    string  wholeSdp;
    
    /**
     * Pointer to its original pjmedia_sdp_session. Only valid when the struct
     * is converted from PJSIP's pjmedia_sdp_session.
     */
    void   *pjSdpSession;

public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjmedia_sdp_session &sdp);
};


/**
 * This structure describes media transport informations. It corresponds to the
 * pjmedia_transport_info structure. The address name field can be empty string
 * if the address in the pjmedia_transport_info is invalid.
 */
struct MediaTransportInfo
{
    /**
     * Address to be advertised as the local address for the RTP socket, 
     * which does not need to be equal as the bound address (for example, 
     * this address can be the address resolved with STUN).
     */
    SocketAddress   localRtpName;

    /**
     * Address to be advertised as the local address for the RTCP socket, 
     * which does not need to be equal as the bound address (for example, 
     * this address can be the address resolved with STUN).
     */
    SocketAddress   localRtcpName;

    /**
     * Remote address where RTP originated from. This can be empty string if 
     * no data is received from the remote.
     */
    SocketAddress   srcRtpName;

    /**
     * Remote address where RTCP originated from. This can be empty string if 
     * no data is recevied from the remote.
     */
    SocketAddress   srcRtcpName;
    
public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjmedia_transport_info &info);
};

//////////////////////////////////////////////////////////////////////////////

/** Array of media direction */
typedef IntVector MediaDirVector;


/**
 * Call settings.
 */
struct CallSetting
{
    /**
     * Bitmask of pjsua_call_flag constants.
     *
     * Default: 0
     * (PJSUA_CALL_INCLUDE_DISABLED_MEDIA is the legacy default value).
     */
    unsigned        flag;
    
    /**
     * This flag controls what methods to request keyframe are allowed on
     * the call. Value is bitmask of pjsua_vid_req_keyframe_method.
     *
     * Default: PJSUA_VID_REQ_KEYFRAME_SIP_INFO |
     *          PJSUA_VID_REQ_KEYFRAME_RTCP_PLI
     */
    unsigned        reqKeyframeMethod;
    
    /**
     * Number of simultaneous active audio streams for this call. Setting
     * this to zero will disable audio in this call.
     *
     * Default: 1
     */
    unsigned        audioCount;
    
    /**
     * Number of simultaneous active video streams for this call. Setting
     * this to zero will disable video in this call.
     *
     * Default: 1 (if video feature is enabled, otherwise it is zero)
     */
    unsigned        videoCount;

    /**
     * Number of simultaneous active text streams for this call. Setting
     * this to zero will disable text in this call.
     *
     * Default: 1
     */
    unsigned        textCount;

    /**
     * Media direction. This setting will only be used if the flag
     * PJSUA_CALL_SET_MEDIA_DIR is set, and it will persist for subsequent
     * offers or answers.
     * For example, a media that is set as PJMEDIA_DIR_ENCODING can only
     * mark the stream in the SDP as sendonly or inactive, but will not
     * become sendrecv in subsequent offers and answers.
     * Application can update the media direction in any API or callback
     * that accepts CallSetting as a parameter, such as via
     * Call::reinvite/update() or in onCallRxOffer/Reinvite()
     * callback.
     *
     * The index of the media dir will correspond to the provisional media
     * in CallInfo.provMedia.
     * For offers that involve adding new medias (such as initial offer),
     * the index will correspond to all new audio media first, then video.
     * For example, for a new call with 2 audios and 1 video, mediaDir[0]
     * and mediaDir[1] will be for the audios, and mediaDir[2] video.
     *
     * Default: empty vector
     */
    MediaDirVector mediaDir;

    /**
     * User defined Call-ID to be sent out with outgoing INVITE.
     *
     * Note: It is up to the developer to verify uniqueness of the
     * Call-ID as there will be no verification. The developer must
     * change the Call-ID between calls creating a unique id for each
     * outgoing call.
     *
     * This setting will only be used when creating a new outgoing call
     * via Call::makeCall().
     */
    string customCallId;

    
public:
    /**
     * Default constructor initializes with empty or default values.
     */
    CallSetting(bool useDefaultValues = false);

    /**
     * Check if the settings are set with empty values.
     *
     * @return      True if the settings are empty.
     */
    bool isEmpty() const;

    /**
     * Convert from pjsip
     */
    void fromPj(const pjsua_call_setting &prm);

    /**
     * Convert to pjsip
     */
    pjsua_call_setting toPj() const;
};

/**
 * Call media information.
 *
 * Application can query conference bridge port of this media using
 * Call::getAudioMedia() if the media type is audio,
 * or Call::getEncodingVideoMedia() / Call::getDecodingVideoMedia()
 * if the media type is video.
 */
struct CallMediaInfo
{
    /**
     * Media index in SDP.
     */
    unsigned                index;
    
    /**
     * Media type.
     */
    pjmedia_type            type;
    
    /**
     * Media direction.
     */
    pjmedia_dir             dir;
    
    /**
     * Call media status.
     */
    pjsua_call_media_status status;
    
    /**
     * Warning: this is deprecated, application can query conference bridge
     * port of this media using Call::getAudioMedia().
     *
     * The conference port number for the call. Only valid if the media type
     * is audio.
     */
    int                     audioConfSlot;
    
    /**
     * The window id for incoming video, if any, or
     * PJSUA_INVALID_ID. Only valid if the media type is video.
     */
    pjsua_vid_win_id        videoIncomingWindowId;
    
    /**
     * The video window instance for incoming video. Only valid if
     * videoIncomingWindowId is not PJSUA_INVALID_ID and
     * the media type is video.
     */
    VideoWindow             videoWindow;

    /**
     * The video capture device for outgoing transmission, if any,
     * or PJMEDIA_VID_INVALID_DEV. Only valid if the media type is video.
     */
    pjmedia_vid_dev_index   videoCapDev;
    
public:
    /**
     * Default constructor
     */
    CallMediaInfo();
    
    /**
     * Convert from pjsip
     */
    void fromPj(const pjsua_call_media_info &prm);
};
    
/** Array of call media info */
typedef std::vector<CallMediaInfo> CallMediaInfoVector;

/**
 * Call information. Application can query the call information
 * by calling Call::getInfo().
 */
struct CallInfo
{
    /**
     * Call identification.
     */
    pjsua_call_id       id;
    
    /**
     * Initial call role (UAC == caller)
     */
    pjsip_role_e        role;
    
    /**
     * The account ID where this call belongs.
     */
    pjsua_acc_id        accId;
    
    /**
     * Local URI
     */
    string              localUri;
    
    /**
     * Local Contact
     */
    string              localContact;
    
    /**
     * Remote URI
     */
    string              remoteUri;
    
    /**
     * Remote contact
     */
    string              remoteContact;
    
    /**
     * Dialog Call-ID string.
     */
    string              callIdString;
    
    /**
     * Call setting
     */
    CallSetting         setting;
    
    /**
     * Call state
     */
    pjsip_inv_state     state;
    
    /**
     * Text describing the state
     */
    string              stateText;
    
    /**
     * Last status code heard, which can be used as cause code
     */
    pjsip_status_code   lastStatusCode;
    
    /**
     * The reason phrase describing the last status.
     */
    string              lastReason;
    
    /**
     * Array of active media information.
     */
    CallMediaInfoVector media;

    /**
     * Array of provisional media information. This contains the media info
     * in the provisioning state, that is when the media session is being
     * created/updated (SDP offer/answer is on progress).
     */
    CallMediaInfoVector provMedia;
    
    /**
     * Up-to-date call connected duration (zero when call is not
     * established)
     */
    TimeVal             connectDuration;
    
    /**
     * Total call duration, including set-up time
     */
    TimeVal             totalDuration;
    
    /**
     * Flag if remote was SDP offerer
     */
    bool                remOfferer;
    
    /**
     * Number of audio streams offered by remote
     */
    unsigned            remAudioCount;
    
    /**
     * Number of video streams offered by remote
     */
    unsigned            remVideoCount;

    /**
     * Number of text streams offered by remote
     */
    unsigned            remTextCount;

public:
    /**
     * Default constructor
     */
    CallInfo() : id(PJSUA_INVALID_ID),
                 role(PJSIP_ROLE_UAC),
                 accId(PJSUA_INVALID_ID),
                 state(PJSIP_INV_STATE_NULL),
                 lastStatusCode(PJSIP_SC_NULL),
                 remOfferer(false),
                 remAudioCount(0),
                 remVideoCount(0),
                 remTextCount(0)
    {}

    /**
     * Convert from pjsip
     */
    void fromPj(const pjsua_call_info &pci);
};

/**
 * Media stream info.
 */
struct StreamInfo
{
    /**
     * Media type of this stream.
     */
    pjmedia_type        type;

    /**
     * Transport protocol (RTP/AVP, etc.)
     */
    pjmedia_tp_proto    proto;
    
    /**
     * Media direction.
     */
    pjmedia_dir         dir;
    
    /**
     * Remote RTP address
     */
    SocketAddress       remoteRtpAddress;
    
    /**
     * Optional remote RTCP address
     */
    SocketAddress       remoteRtcpAddress;
    
    /**
     * Outgoing codec payload type.
     */
    unsigned            txPt;
    
    /**
     * Incoming codec payload type.
     */
    unsigned            rxPt;

    /**
     * Outgoing pt for audio telephone-events.
     */
    int                 audTxEventPt;

    /**
     * Incoming pt for audio telephone-events.
     */
    int                 audRxEventPt;
    
    /**
     * Codec name.
     */
    string              codecName;
    
    /**
     * Codec clock rate.
     */
    unsigned            codecClockRate;
    
    /**
     * Optional audio codec param.
     */
    CodecParam          audCodecParam;

    /**
     * Optional video codec param.
     */
    VidCodecParam       vidCodecParam;

    /**
     * Jitter buffer init delay in msec.
     */
    int                 jbInit;

    /**
     * Jitter buffer minimum prefetch delay in msec.
     */
    int                 jbMinPre;

    /**
     * Jitter buffer maximum prefetch delay in msec.
     */
    int                 jbMaxPre;

    /**
     * Jitter buffer max delay in msec.
     */
    int                 jbMax;

    /**
     * Jitter buffer discard algorithm.
     */
    pjmedia_jb_discard_algo jbDiscardAlgo;

#if defined(PJMEDIA_STREAM_ENABLE_KA) && PJMEDIA_STREAM_ENABLE_KA!=0
    /**
     * Stream keep-alive and NAT hole punch (see #PJMEDIA_STREAM_ENABLE_KA) is
     * enabled?
     */
    bool                useKa;

    /**
     *  Number of keepalive messages to be sent
     */
    unsigned            startCountKa;

    /**
     * Keepalive interval after the stream is created.
     */
    unsigned startIntervalKa;

    /**
     *  Keepalive sending interval.
     */
    unsigned intervalKa;
#endif

    /**
     * Disable automatic sending of RTCP SDES and BYE.
     */
    bool                rtcpSdesByeDisabled;

public:
    /**
     * Default constructor
     */
    StreamInfo() 
    : type(PJMEDIA_TYPE_NONE),
      proto(PJMEDIA_TP_PROTO_NONE),
      dir(PJMEDIA_DIR_NONE),
      txPt(0),
      rxPt(0),
      audTxEventPt(0),
      audRxEventPt(0),
      codecClockRate(0),
      jbInit(-1),
      jbMinPre(-1),
      jbMaxPre(-1),
      jbMax(-1),
      jbDiscardAlgo(PJMEDIA_JB_DISCARD_NONE),
#if defined(PJMEDIA_STREAM_ENABLE_KA) && PJMEDIA_STREAM_ENABLE_KA!=0
      useKa(false),
#endif
      rtcpSdesByeDisabled(false)
    {}

    /**
     * Convert from pjsip
     */
    void fromPj(const pjsua_stream_info &info);
};

/**
 * Media stream statistic.
 */
struct StreamStat
{
    /**
     * RTCP statistic.
     */
    RtcpStat    rtcp;
    
    /**
     * Jitter buffer statistic.
     */
    JbufState   jbuf;

public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjsua_stream_stat &prm);
};

/**
 * This structure contains parameters for Call::onCallState() callback.
 */
struct OnCallStateParam
{
    /**
     * Event which causes the call state to change.
     */
    SipEvent    e;
};

/**
 * This structure contains parameters for Call::onCallTsxState() callback.
 */
struct OnCallTsxStateParam
{
    /**
     * Transaction event that caused the state change.
     */
    SipEvent    e;
};

/**
 * This structure contains parameters for Call::onCallMediaState() callback.
 */
struct OnCallMediaStateParam
{
};

/**
 * This structure contains parameters for Call::onCallSdpCreated() callback.
 */
struct OnCallSdpCreatedParam
{
    /**
     * The SDP has just been created.
     */
    SdpSession sdp;

    /**
     * The remote SDP, will be empty if local is SDP offerer.
     */
    SdpSession remSdp;
};

/**
 * This structure contains parameters for Call::onStreamPreCreate()
 * callback.
 */
struct OnStreamPreCreateParam
{
    /**
     * Stream index in the media session, read-only.
     */
    unsigned    streamIdx;

    /**
     * Parameters that the stream will be created from.
     */
    StreamInfo streamInfo;
};

/**
 * This structure contains parameters for Call::onStreamCreated()
 * callback.
 */
struct OnStreamCreatedParam
{
    /**
     * Audio media stream, read-only.
     */
    MediaStream stream;
    
    /**
     * Stream index in the audio media session, read-only.
     */
    unsigned    streamIdx;
    
    /**
     * Specify if PJSUA2 should take ownership of the port returned in
     * the pPort parameter below. If set to true,
     * pjmedia_port_destroy() will be called on the port when it is
     * no longer needed.
     *
     * Default: false
     */
    bool        destroyPort;

    /**
     * On input, it specifies the audio media port of the stream. Application
     * may modify this pointer to point to different media port to be
     * registered to the conference bridge.
     */
    MediaPort   pPort;
};

/**
 * This structure contains parameters for Call::onStreamDestroyed()
 * callback.
 */
struct OnStreamDestroyedParam
{
    /**
     * Audio media stream.
     */
    MediaStream stream;
    
    /**
     * Stream index in the audio media session.
     */
    unsigned    streamIdx;
};

/**
 * This structure contains parameters for Call::onDtmfDigit()
 * callback.
 */
struct OnDtmfDigitParam
{
    /**
     * DTMF sending method.
     */
    pjsua_dtmf_method   method;

    /**
     * DTMF ASCII digit.
     */
    string              digit;

    /**
     * DTMF signal duration. If the duration is unknown, this value is set to
     * PJSUA_UNKNOWN_DTMF_DURATION.
     */
    unsigned            duration;
};

/**
 * This structure contains parameters for Call::onDtmfEvent()
 * callback.
 */
struct OnDtmfEventParam
{
    /**
     * DTMF sending method.
     */
    pjsua_dtmf_method   method;

    /**
     * The timestamp identifying the begin of the event. Timestamp units are
     * expressed in milliseconds.
     * Note that this value should only be used to compare multiple events
     * received via the same method relatively to each other, as the time-base
     * is randomized.
     */
    unsigned            timestamp;

    /**
     * DTMF ASCII digit.
     */
    string              digit;

    /**
     * DTMF signal duration in milliseconds. Interpretation of the duration
     * depends on the flag PJMEDIA_STREAM_DTMF_IS_END.
     * depends on the method.
     * If the method is PJSUA_DTMF_METHOD_SIP_INFO, this contains the total
     * duration of the DTMF signal or PJSUA_UNKNOWN_DTMF_DURATION if no signal
     * duration was indicated.
     * If the method is PJSUA_DTMF_METHOD_RFC2833, this contains the total
     * duration of the DTMF signal received up to this point in time.
     */
    unsigned            duration;

    /**
     * Flags indicating additional information about the DTMF event.
     * If PJMEDIA_STREAM_DTMF_IS_UPDATE is set, the event was already
     * indicated earlier. The new indication contains an updated event
     * duration.
     * If PJMEDIA_STREAM_DTMF_IS_END is set, the event has ended and this
     * indication contains the final event duration. Note that end
     * indications might get lost. Hence it is not guaranteed to receive
     * an event with PJMEDIA_STREAM_DTMF_IS_END for every event.
     */
    unsigned            flags;
};

/**
 * This structure contains parameters for Call::onCallRxText()
 * callback.
 */
struct OnCallRxTextParam
{
    /**
     * The sequence of the incoming text block data.
     */
    int                 seq;

    /**
     * The timestamp of the text block data.
     */
    unsigned            ts;

    /**
     * The content of the text block.
     * Note that the text can be empty.
     */
    string              text;

public:
    /**
     * Convert from pjsip
     */
    void fromPj(const pjsua_txt_stream_data &prm);
};

/**
 * This structure contains parameters for Call::onCallTransferRequest()
 * callback.
 */
struct OnCallTransferRequestParam
{
    /**
     * The destination where the call will be transferred to.
     */
    string               dstUri;
    
    /**
     * Status code to be returned for the call transfer request. On input,
     * it contains status code 202.
     */
    pjsip_status_code    statusCode;
    
    /**
     * The current call setting, application can update this setting
     * for the call being transferred.
     */
    CallSetting          opt;

    /**
     * New Call derived object instantiated by application when the call
     * transfer is about to be accepted.
     */
    Call                *newCall;
};

/**
 * This structure contains parameters for Call::onCallTransferStatus()
 * callback.
 */
struct OnCallTransferStatusParam
{
    /**
     * Status progress of the transfer request.
     */
    pjsip_status_code   statusCode;
    
    /**
     * Status progress reason.
     */
    string              reason;
    
    /**
     * If true, no further notification will be reported. The statusCode
     * specified in this callback is the final status.
     */
    bool                finalNotify;
    
    /**
     * Initially will be set to true, application can set this to false
     * if it no longer wants to receive further notification (for example,
     * after it hangs up the call).
     */
    bool                cont;
};

/**
 * This structure contains parameters for Call::onCallReplaceRequest()
 * callback.
 */
struct OnCallReplaceRequestParam
{
    /**
     * The incoming INVITE request to replace the call.
     */
    SipRxData           rdata;
    
    /**
     * Status code to be set by application. Application should only
     * return a final status (>= PJSIP_SC_OK (200))
     */
    pjsip_status_code   statusCode;
    
    /**
     * Optional status text to be set by application.
     */
    string              reason;
    
    /**
     * The current call setting, application can update this setting for
     * the call being replaced.
     */
    CallSetting         opt;

    /**
     * New Call derived object instantiated by application.
     */
    Call                *newCall;
};

/**
 * This structure contains parameters for Call::onCallReplaced() callback.
 */
struct OnCallReplacedParam
{
    /**
     * The new call id.
     */
    pjsua_call_id        newCallId;

    /**
     * New Call derived object instantiated by application.
     */
    Call                *newCall;
};

/**
 * This structure contains parameters for Call::onCallRxOffer() callback.
 */
struct OnCallRxOfferParam
{
    /**
     * The new offer received.
     */
    SdpSession          offer;
    
    /**
     * Status code to be returned for answering the offer. On input,
     * it contains status code PJSIP_SC_OK (200). Currently, valid values are only
     * PJSIP_SC_OK (200) and PJSIP_SC_NOT_ACCEPTABLE_HERE (488).
     */
    pjsip_status_code   statusCode;
    
    /**
     * The current call setting, application can update this setting for
     * answering the offer.
     */
    CallSetting         opt;
};

/**
 * This structure contains parameters for Call::onCallRxReinvite() callback.
 */
struct OnCallRxReinviteParam
{
    /**
     * The new offer received.
     */
    SdpSession          offer;

    /**
     * The incoming re-INVITE.
     */
    SipRxData           rdata;
    
    /**
     * On input, it is false. Set to true if app wants to manually answer
     * the re-INVITE.
     */
    bool                isAsync;
    
    /**
     * Status code to be returned for answering the offer. On input,
     * it contains status code PJSIP_SC_OK (200). Currently, valid values are only
     * PJSIP_SC_OK (200) and PJSIP_SC_NOT_ACCEPTABLE_HERE (488).
     */
    pjsip_status_code   statusCode;
    
    /**
     * The current call setting, application can update this setting for
     * answering the offer.
     */
    CallSetting         opt;
};

/**
 * This structure contains parameters for Call::onCallTxOffer() callback.
 */
struct OnCallTxOfferParam
{
    /**
     * The current call setting, application can update this setting for
     * generating the offer. Note that application should maintain any
     * active media to avoid the need for the peer to reject the offer.
     */
    CallSetting         opt;
};

/**
 * This structure contains parameters for Call::onCallRedirected() callback.
 */
struct OnCallRedirectedParam
{
    /**
     * The current target to be tried.
     */
    string          targetUri;
    
    /**
     * The event that caused this callback to be called.
     * This could be the receipt of 3xx response, or 4xx/5xx response
     * received for the INVITE sent to subsequent targets, or empty
     * (e.type == PJSIP_EVENT_UNKNOWN) if this callback is called from 
     * within Call::processRedirect() context.
     */
    SipEvent        e;
};

/**
 * This structure contains parameters for Call::onCallMediaEvent() callback.
 */
struct OnCallMediaEventParam
{
    /**
     * The media stream index.
     */
    unsigned        medIdx;
    
    /**
     * The media event.
     */
    MediaEvent      ev;
};

/**
 * This structure contains parameters for Call::onCallMediaTransportState()
 * callback.
 */
struct OnCallMediaTransportStateParam
{
    /**
     * The media index.
     */
    unsigned        medIdx;
    
    /**
     * The media transport state
     */
    pjsua_med_tp_st state;
    
    /**
     * The last error code related to the media transport state.
     */
    pj_status_t     status;
    
    /**
     * Optional SIP error code.
     */
    int             sipErrorCode;
};

/**
 * This structure contains parameters for Call::onCreateMediaTransport()
 * callback.
 */
struct OnCreateMediaTransportParam
{
    /**
     * The media index in the SDP for which this media transport will be used.
     */
    unsigned        mediaIdx;
    
    /**
     * The media transport which otherwise will be used by the call has this
     * callback not been implemented. Application can change this to its own
     * instance of media transport to be used by the call.
     */
    MediaTransport  mediaTp;
    
    /**
     * Bitmask from pjsua_create_media_transport_flag.
     */
    unsigned        flags;
};

/**
 * This structure contains parameters for Call::onCreateMediaTransportSrtp()
 * callback.
 */
struct OnCreateMediaTransportSrtpParam
{
    /**
     * The media index in the SDP for which the SRTP media transport
     * will be used.
     */
    unsigned                    mediaIdx;
    
    /**
     * Specify whether secure media transport should be used. Application
     * can modify this only for initial INVITE.
     * Valid values are PJMEDIA_SRTP_DISABLED, PJMEDIA_SRTP_OPTIONAL, and
     * PJMEDIA_SRTP_MANDATORY.
     */
    pjmedia_srtp_use            srtpUse;
    
    /**
     * Application can modify this to specify the cryptos and keys
     * which are going to be used.
     */
    SrtpCryptoVector            cryptos;
};

/**
 * @}  // PJSUA2_Call_Data_Structure
 */

/**
 * @addtogroup PJSUA2_CALL
 * @{
 */

/**
 * This structure contains parameters for Call::answer(), Call::hangup(),
 * Call::reinvite(), Call::update(), Call::xfer(), Call::xferReplaces(),
 * Call::setHold().
 */
struct CallOpParam
{
    /**
     * The call setting.
     */
    CallSetting         opt;
    
    /**
     * Status code.
     */
    pjsip_status_code   statusCode;
    
    /**
     * Reason phrase.
     */
    string              reason;
    
    /**
     * Options.
     */
    unsigned            options;
    
    /**
     * List of headers etc to be added to outgoing response message.
     * Note that this message data will be persistent in all next
     * answers/responses for this INVITE request.
     */
    SipTxOption         txOption;

    /**
     * SDP answer. Currently only used for Call::answer().
     */
    SdpSession          sdp;
    
public:
    /**
     * Default constructor initializes with zero/empty values.
     * Setting useDefaultCallSetting to true will initialize opt with default
     * call setting values.
     */
    CallOpParam(bool useDefaultCallSetting = false);
};

/**
 * This structure contains parameters for Call::sendRequest()
 */
struct CallSendRequestParam
{
    /**
     * SIP method of the request.
     */
    string       method;
    
    /**
     * Message body and/or list of headers etc to be included in
     * outgoing request.
     */
    SipTxOption  txOption;
    
public:
    /**
     * Default constructor initializes with zero/empty values.
     */
    CallSendRequestParam();
};

/**
 * This structure contains parameters for Call::vidSetStream()
 */
struct CallVidSetStreamParam
{
    /**
     * Specify the media stream index. This can be set to -1 to denote
     * the default video stream in the call, which is the first active
     * video stream or any first video stream if none is active.
     *
     * This field is valid for all video stream operations, except
     * PJSUA_CALL_VID_STRM_ADD.
     *
     * Default: -1 (first active video stream, or any first video stream
     *              if none is active)
     */
    int                     medIdx;
    
    /**
     * Specify the media stream direction.
     *
     * This field is valid for the following video stream operations:
     * PJSUA_CALL_VID_STRM_ADD and PJSUA_CALL_VID_STRM_CHANGE_DIR.
     *
     * Default: PJMEDIA_DIR_ENCODING_DECODING
     */
    pjmedia_dir             dir;
    
    /**
     * Specify the video capture device ID. This can be set to
     * PJMEDIA_VID_DEFAULT_CAPTURE_DEV to specify the default capture
     * device as configured in the account.
     *
     * This field is valid for the following video stream operations:
     * PJSUA_CALL_VID_STRM_ADD and PJSUA_CALL_VID_STRM_CHANGE_CAP_DEV.
     *
     * Default: PJMEDIA_VID_DEFAULT_CAPTURE_DEV.
     */
    pjmedia_vid_dev_index   capDev;
    
public:
    /**
     * Default constructor
     */
    CallVidSetStreamParam();
};

/**
 * This structure contains parameters for Call::sendDtmf()
 */
struct CallSendDtmfParam
{
    /**
     * The method used to send DTMF.
     * 
     * Default: PJSUA_DTMF_METHOD_RFC2833
     */
    pjsua_dtmf_method method;    

    /**
     * The signal duration used for the DTMF.
     *
     * Default: PJSUA_CALL_SEND_DTMF_DURATION_DEFAULT
     */
    unsigned duration;

    /**
     * The DTMF digits to be sent.
     */
    string digits;

public:
    /**
     * Default constructor initialize with default value.     
     */
    CallSendDtmfParam();

    /**
     * Convert to pjsip.
     */
    pjsua_call_send_dtmf_param toPj() const;

    /**
     * Convert from pjsip.
     */
    void fromPj(const pjsua_call_send_dtmf_param &param);
};

/**
 * This structure contains parameters for Call::sendText()
 */
struct CallSendTextParam
{
    /**
     * Specify the text media stream index. This can be set to -1 to denote
     * the first text stream in the call.
     *
     * Default: -1 (first text stream)
     */
    int     medIdx;

    /**
     * The text data to be sent.
     */
    string  text;

public:
    /**
     * Default constructor initializes with default value.
     */
    CallSendTextParam();
};


/**
 * Call.
 */
class Call
{
public:
    /**
     * Constructor.
     */
    Call(Account& acc, int call_id = PJSUA_INVALID_ID);

    /**
     * Destructor.
     */
    virtual ~Call();

    /**
     * Obtain detail information about this call.
     *
     * @return              Call info.
     */
    CallInfo getInfo() const PJSUA2_THROW(Error);
    
    /**
     * Check if this call has active INVITE session and the INVITE
     * session has not been disconnected.
     *
     * @return              True if call is active.
     */
    bool isActive() const;

    /**
     * Get PJSUA-LIB call ID or index associated with this call.
     *
     * @return              Integer greater than or equal to zero.
     */
    int getId() const;
    
    /**
     * Get the Call class for the specified call Id.
     *
     * @param call_id       The call ID to lookup
     *
     * @return              The Call instance or NULL if not found.
     */
    static Call *lookup(int call_id);

    /**
     * Check if call has an active media session.
     *
     * @return              True if yes.
     */
    bool hasMedia() const;
    
    /**
     * Warning: deprecated, use getAudioMedia() instead. This function is not
     * safe in multithreaded environment.
     *
     * Get media for the specified media index.
     *
     * @param med_idx       Media index.
     *
     * @return              The media or NULL if invalid or inactive.
     */
    Media *getMedia(unsigned med_idx) const;

    /**
     * Get audio media for the specified media index. If the specified media
     * index is not audio or invalid or inactive, exception will be thrown.
     *
     * @param med_idx       Media index, or -1 to specify any first audio
     *                      media registered in the conference bridge.
     *
     * @return              The audio media.
     */
    AudioMedia getAudioMedia(int med_idx) const PJSUA2_THROW(Error);

    /**
     * Get video media in encoding direction for the specified media index.
     * If the specified media index is not video or invalid or the direction
     * is receive only, exception will be thrown.
     *
     * @param med_idx       Media index, or -1 to specify any first video
     *                      media with encoding direction registered in the
     *                      conference bridge.
     *
     * @return              The video media.
     */
    VideoMedia getEncodingVideoMedia(int med_idx) const PJSUA2_THROW(Error);

    /**
     * Get video media in decoding direction for the specified media index.
     * If the specified media index is not video or invalid or the direction
     * is send only, exception will be thrown.
     *
     * @param med_idx       Media index, or -1 to specify any first video
     *                      media with decoding direction registered in the
     *                      conference bridge.
     *
     * @return              The video media.
     */
    VideoMedia getDecodingVideoMedia(int med_idx) const PJSUA2_THROW(Error);

    /**
     * Check if remote peer support the specified capability.
     *
     * @param htype         The header type (pjsip_hdr_e) to be checked, which
     *                      value may be:
     *                      - PJSIP_H_ACCEPT
     *                      - PJSIP_H_ALLOW
     *                      - PJSIP_H_SUPPORTED
     * @param hname         If htype specifies PJSIP_H_OTHER, then the header
     *                      name must be supplied in this argument. Otherwise
     *                      the value must be set to empty string ("").
     * @param token         The capability token to check. For example, if \a
     *                      htype is PJSIP_H_ALLOW, then \a token specifies the
     *                      method names; if \a htype is PJSIP_H_SUPPORTED, then
     *                      \a token specifies the extension names such as
     *                      "100rel".
     *
     * @return              PJSIP_DIALOG_CAP_SUPPORTED if the specified
     *                      capability is explicitly supported, see
     *                      pjsip_dialog_cap_status for more info.
     */
    pjsip_dialog_cap_status remoteHasCap(int htype,
                                         const string &hname,
                                         const string &token) const;
    
    /**
     * Attach application specific data to the call. Application can then
     * inspect this data by calling getUserData().
     *
     * @param user_data     Arbitrary data to be attached to the call.
     */
    void setUserData(Token user_data);
    
    /**
     * Get user data attached to the call, which has been previously set with
     * setUserData().
     *
     * @return              The user data.
     */
    Token getUserData() const;
    
    /**
     * Get the NAT type of remote's endpoint. This is a proprietary feature
     * of PJSUA-LIB which sends its NAT type in the SDP when \a natTypeInSdp
     * is set in UaConfig.
     *
     * This function can only be called after SDP has been received from remote,
     * which means for incoming call, this function can be called as soon as
     * call is received as long as incoming call contains SDP, and for outgoing
     * call, this function can be called only after SDP is received (normally in
     * PJSIP_SC_OK (200) response to INVITE). As a general case, application
     * should call this function after or in \a onCallMediaState() callback.
     *
     * @return              The NAT type.
     *
     * @see Endpoint::natGetType(), natTypeInSdp
     */
    pj_stun_nat_type getRemNatType() PJSUA2_THROW(Error);

    /**
     * Make outgoing call to the specified URI.
     *
     * @param dst_uri       URI to be put in the To header (normally is the same
     *                      as the target URI).
     * @param prm.opt       Optional call setting.
     * @param prm.txOption  Optional headers etc to be added to outgoing INVITE
     *                      request.
     */
    void makeCall(const string &dst_uri, const CallOpParam &prm)
                  PJSUA2_THROW(Error);

    /**
     * Send response to incoming INVITE request with call setting param.
     * Depending on the status code specified as parameter, this function may
     * send provisional response, establish the call, or terminate the call.
     * Notes about call setting:
     *  - if call setting is changed in the subsequent call to this function,
     *    only the first call setting supplied will applied. So normally
     *    application will not supply call setting before getting confirmation
     *    from the user.
     *  - if no call setting is supplied when SDP has to be sent, i.e: answer
     *    with status code 183 or 2xx, the default call setting will be used,
     *    check CallSetting for its default values.
     *
     * @param prm.opt       Optional call setting.
     * @param prm.statusCode   Status code, (>= PJSIP_SC_TRYING (100)).
     * @param prm.reason    Optional reason phrase. If empty, default text
     *                      will be used.
     * @param prm.txOption  Optional list of headers etc to be added to outgoing
     *                      response message. Note that this message data will
     *                      be persistent in all next answers/responses for this
     *                      INVITE request.
     */
    void answer(const CallOpParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Hangup call by using method that is appropriate according to the
     * call state. This function is different than answering the call with
     * 3xx-6xx response (with answer()), in that this function
     * will hangup the call regardless of the state and role of the call,
     * while answer() only works with incoming calls on EARLY
     * state.
     *
     * @param prm.statusCode
     *                      Optional status code to be sent when we're rejecting
     *                      incoming call. If the value is zero, "603/Decline"
     *                      will be sent.
     * @param prm.reason    Optional reason phrase to be sent when we're
     *                      rejecting incoming call. If empty, default text
     *                      will be used.
     * @param prm.txOption  Optional list of headers etc to be added to outgoing
     *                      request/response message.
     */
    void hangup(const CallOpParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Put the specified call on hold. This will send re-INVITE with the
     * appropriate SDP to inform remote that the call is being put on hold.
     * The final status of the request itself will be reported on the
     * \a onCallMediaState() callback, which inform the application that
     * the media state of the call has changed.
     *
     * @param prm.options   Bitmask of pjsua_call_flag constants. Currently,
     *                      only the flag PJSUA_CALL_UPDATE_CONTACT can be used.
     * @param prm.txOption  Optional message components to be sent with
     *                      the request.
     */
    void setHold(const CallOpParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Send re-INVITE.
     * The final status of the request itself will be reported on the
     * \a onCallMediaState() callback, which inform the application that
     * the media state of the call has changed.
     *
     * @param prm.opt       Optional call setting, if empty, the current call
     *                      setting will remain unchanged.
     * @param prm.opt.flag  Bitmask of pjsua_call_flag constants. Specifying
     *                      PJSUA_CALL_UNHOLD here will release call hold.
     * @param prm.txOption  Optional message components to be sent with
     *                      the request.
     */
    void reinvite(const CallOpParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Send UPDATE request.
     *
     * @param prm.opt       Optional call setting, if empty, the current call
     *                      setting will remain unchanged.
     * @param prm.txOption  Optional message components to be sent with
     *                      the request.
     */
    void update(const CallOpParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Initiate call transfer to the specified address. This function will send
     * REFER request to instruct remote call party to initiate a new INVITE
     * session to the specified destination/target.
     *
     * If application is interested to monitor the successfulness and
     * the progress of the transfer request, it can implement
     * \a onCallTransferStatus() callback which will report the progress
     * of the call transfer request.
     *
     * @param dest          URI of new target to be contacted. The URI may be
     *                      in name address or addr-spec format.
     * @param prm.txOption  Optional message components to be sent with
     *                      the request.
     */
    void xfer(const string &dest, const CallOpParam &prm) PJSUA2_THROW(Error);

    /**
     * Initiate attended call transfer. This function will send REFER request
     * to instruct remote call party to initiate new INVITE session to the URL
     * of \a destCall. The party at \a dest_call then should "replace"
     * the call with us with the new call from the REFER recipient.
     *
     * @param dest_call     The call to be replaced.
     * @param prm.options   Application may specify
     *                      PJSUA_XFER_NO_REQUIRE_REPLACES to suppress the 
     *                      inclusion of "Require: replaces" in
     *                      the outgoing INVITE request created by the REFER
     *                      request.
     * @param prm.txOption  Optional message components to be sent with
     *                      the request.
     */
    void xferReplaces(const Call& dest_call,
                      const CallOpParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Accept or reject redirection response. Application MUST call this
     * function after it signaled PJSIP_REDIRECT_PENDING in the 
     * \a onCallRedirected() callback,
     * to notify the call whether to accept or reject the redirection
     * to the current target. Application can use the combination of
     * PJSIP_REDIRECT_PENDING command in \a onCallRedirected() callback and
     * this function to ask for user permission before redirecting the call.
     *
     * Note that if the application chooses to reject or stop redirection (by
     * using PJSIP_REDIRECT_REJECT or PJSIP_REDIRECT_STOP respectively), the
     * call disconnection callback will be called before this function returns.
     * And if the application rejects the target, the \a onCallRedirected()
     * callback may also be called before this function returns if there is
     * another target to try.
     *
     * @param cmd           Redirection operation to be applied to the current
     *                      target. The semantic of this argument is similar
     *                      to the description in the \a onCallRedirected()
     *                      callback, except that the PJSIP_REDIRECT_PENDING is
     *                      not accepted here.
     */
    void processRedirect(pjsip_redirect_op cmd) PJSUA2_THROW(Error);

    /**
     * Send DTMF digits to remote using RFC 2833 payload formats.
     *
     * @param digits        DTMF string digits to be sent.
     */
    void dialDtmf(const string &digits) PJSUA2_THROW(Error);

    /**
     * Send DTMF digits to remote.
     *
     * @param param     The send DTMF parameter.
     */
    void sendDtmf(const CallSendDtmfParam &param) PJSUA2_THROW(Error);
    
    /**
     * Send real-time text to remote via RTP stream. This only works if
     * the call has text media.
     *
     * @param param     The send text parameter.
     */
    void sendText(const CallSendTextParam &param) PJSUA2_THROW(Error);

    /**
     * Send instant messaging inside INVITE session.
     *
     * @param prm.contentType
     *                      MIME type.
     * @param prm.content   The message content.
     * @param prm.txOption  Optional list of headers etc to be included in
     *                      outgoing request. The body descriptor in the
     *                      txOption is ignored.
     * @param prm.userData  Optional user data, which will be given back when
     *                      the IM callback is called.
     */
    void sendInstantMessage(const SendInstantMessageParam& prm)
                            PJSUA2_THROW(Error);
    
    /**
     * Send IM typing indication inside INVITE session.
     *
     * @param prm.isTyping  True to indicate to remote that local person is
     *                      currently typing an IM.
     * @param prm.txOption  Optional list of headers etc to be included in
     *                      outgoing request.
     */
    void sendTypingIndication(const SendTypingIndicationParam &prm)
         PJSUA2_THROW(Error);
    
    /**
     * Send arbitrary request with the call. This is useful for example to send
     * INFO request. Note that application should not use this function to send
     * requests which would change the invite session's state, such as
     * re-INVITE, UPDATE, PRACK, and BYE.
     *
     * @param prm.method    SIP method of the request.
     * @param prm.txOption  Optional message body and/or list of headers to be
     *                      included in outgoing request.
     */
    void sendRequest(const CallSendRequestParam &prm) PJSUA2_THROW(Error);
    
    /**
     * Dump call and media statistics to string.
     *
     * @param with_media    True to include media information too.
     * @param indent        Spaces for left indentation.
     *
     * @return              Call dump and media statistics string.
     */
    string dump(bool with_media, const string indent) PJSUA2_THROW(Error);
    
    /**
     * Get the media stream index of the default video stream in the call.
     * Typically this will just retrieve the stream index of the first
     * activated video stream in the call. If none is active, it will return
     * the first inactive video stream.
     *
     * @return              The media stream index or -1 if no video stream
     *                      is present in the call.
     */
    int vidGetStreamIdx() const;
    
    /**
     * Determine if video stream for the specified call is currently running
     * (i.e. has been created, started, and not being paused) for the specified
     * direction.
     *
     * @param med_idx       Media stream index, or -1 to specify default video
     *                      media.
     * @param dir           The direction to be checked.
     *
     * @return              True if stream is currently running for the
     *                      specified direction.
     */
    bool vidStreamIsRunning(int med_idx, pjmedia_dir dir) const;
    
    /**
     * Add, remove, modify, and/or manipulate video media stream for the
     * specified call. This may trigger a re-INVITE or UPDATE to be sent
     * for the call.
     *
     * @param op            The video stream operation to be performed,
     *                      possible values are pjsua_call_vid_strm_op.
     * @param param         The parameters for the video stream operation
     *                      (see CallVidSetStreamParam).
     */
    void vidSetStream(pjsua_call_vid_strm_op op,
                      const CallVidSetStreamParam &param) PJSUA2_THROW(Error);

    /**
     * Modify the video stream's codec parameter after the codec is opened.
     * Note that not all codec backends support modifying parameters during
     * runtime and only certain parameters can be changed.
     *
     * Currently, only Video Toolbox and OpenH264 backends support runtime
     * adjustment of encoding bitrate (avg_bps and max_bps).
     *
     * @param med_idx       Video stream index.
     * @param param         The new codec parameter.
     *
     * @return              PJ_SUCCESS on success.
     */
    void vidStreamModifyCodecParam(int med_idx, const VidCodecParam &param)
                                   PJSUA2_THROW(Error);

    /**
     * Modify the audio stream's codec parameter after the codec is opened.
     * Note that not all codec parameters can be modified during run-time.
     * Currently, only Opus codec supports changing key codec parameters
     * such as bitrate and bandwidth, while other codecs may only be able to
     * modify minor settings such as VAD or PLC.
     *
     * @param med_idx       Media stream index, or -1 to specify default audio
     *                      media.
     * @param param         The new codec parameter.
     *
     * @return              PJ_SUCCESS on success.
     */
    void audStreamModifyCodecParam(int med_idx, const CodecParam &param)
                                   PJSUA2_THROW(Error);

    /**
     * Get media stream info for the specified media index.
     *
     * @param med_idx       Media stream index.
     *
     * @return              The stream info.
     */
    StreamInfo getStreamInfo(unsigned med_idx) const PJSUA2_THROW(Error);
    
    /**
     * Get media stream statistic for the specified media index.
     *
     * @param med_idx       Media stream index.
     *
     * @return              The stream statistic.
     */
    StreamStat getStreamStat(unsigned med_idx) const PJSUA2_THROW(Error);
    
    /**
     * Get media transport info for the specified media index.
     *
     * @param med_idx       Media stream index.
     *
     * @return              The transport info.
     */
    MediaTransportInfo getMedTransportInfo(unsigned med_idx) const
                                           PJSUA2_THROW(Error);

    /**
     * Internal function (callled by Endpoint( to process update to call
     * medias when call media state changes.
     */
    void processMediaUpdate(OnCallMediaStateParam &prm);

    /**
     * Internal function (called by Endpoint) to process call state change.
     */
    void processStateChange(OnCallStateParam &prm);
    
public:
    /*
     * Callbacks
     */
    /**
     * Notify application when call state has changed.
     * Application may then query the call info to get the
     * detail call states by calling getInfo() function.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallState(OnCallStateParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * This is a general notification callback which is called whenever
     * a transaction within the call has changed state. Application can
     * implement this callback for example to monitor the state of
     * outgoing requests, or to answer unhandled incoming requests
     * (such as INFO) with a final response.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallTsxState(OnCallTsxStateParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application when media state in the call has changed.
     * Normal application would need to implement this callback, e.g.
     * to connect the call's media to sound device. When ICE is used,
     * this callback will also be called to report ICE negotiation
     * failure.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallMediaState(OnCallMediaStateParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application when a call has just created a local SDP (for
     * initial or subsequent SDP offer/answer). Application can implement
     * this callback to modify the SDP, before it is being sent and/or
     * negotiated with remote SDP, for example to apply per account/call
     * basis codecs priority or to add custom/proprietary SDP attributes.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallSdpCreated(OnCallSdpCreatedParam &prm)
    { PJ_UNUSED_ARG(prm); }

    /**
     * Notify application when an audio media session is about to be created
     * (as opposed to onStreamCreated(), which is called *after* the session
     * has been created). The application may change
     * some stream info parameter values, i.e: jbInit, jbMinPre, jbMaxPre,
     * jbMax, useKa, startCountKa, startIntervalKa, intervalKa,
     * rtcpSdesByeDisabled, jbDiscardAlgo (audio), vidCodecParam.encFmt (video).
     *
     * @param prm       Callback parameter.
     */
    virtual void onStreamPreCreate(OnStreamPreCreateParam &prm)
    { PJ_UNUSED_ARG(prm); }

    /**
     * Notify application when audio media session is created and before it is
     * registered to the conference bridge. Application may return different
     * audio media port if it has added media processing port to the stream.
     * This media port then will be added to the conference bridge instead.
     *
     * @param prm       Callback parameter.
     */
    virtual void onStreamCreated(OnStreamCreatedParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application when audio media session has been unregistered from
     * the conference bridge and about to be destroyed.
     *
     * @param prm       Callback parameter.
     */
    virtual void onStreamDestroyed(OnStreamDestroyedParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application upon incoming DTMF digits.
     *
     * @param prm       Callback parameter.
     */
    virtual void onDtmfDigit(OnDtmfDigitParam &prm)
    { PJ_UNUSED_ARG(prm); }

    /**
     * Notify application upon incoming DTMF events.
     *
     * @param prm       Callback parameter.
     */
    virtual void onDtmfEvent(OnDtmfEventParam &prm)
    { PJ_UNUSED_ARG(prm); }

    /**
     * Notify application upon incoming text data from the text stream.
     * Note that the received text can be empty.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallRxText(OnCallRxTextParam &prm)
    { PJ_UNUSED_ARG(prm); }

    /**
     * Notify application on call being transferred (i.e. REFER is received).
     * Application can decide to accept/reject transfer request by setting
     * the code (default is 202). When this callback is not implemented,
     * the default behavior is to accept the transfer.
     *
     * If application decides to accept the transfer request, it must also
     * instantiate the new Call object for the transfer operation and return
     * this new Call object to prm.newCall. For the new Call instance,
     * the account should use the same account as this call and the call ID
     * must be set to PJSUA_INVALID_ID.
     * 
     * If application does not specify new Call object, library will reuse the
     * existing Call object for initiating the new call (to the transfer
     * destination). In this case, any events from both calls (transferred and
     * transferring) will be delivered to the same Call object, where the call
     * ID will be switched back and forth between callbacks. Application must
     * be careful to not destroy the Call object when receiving disconnection
     * event of the transferred call after the transfer process is completed.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallTransferRequest(OnCallTransferRequestParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application of the status of previously sent call
     * transfer request. Application can monitor the status of the
     * call transfer request, for example to decide whether to
     * terminate existing call.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallTransferStatus(OnCallTransferStatusParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application about incoming INVITE with Replaces header.
     * Application may reject the request by setting non-2xx code.
     *
     * In this callback, application should create a new Call instance and
     * return the Call object via prm.newCall. In creating the new Call
     * instance, the account should use the same account as this call and
     * the call ID must be set to PJSUA_INVALID_ID.
     *
     * If application does not specify new Call object, library will reuse the
     * existing Call object for callbacks. In this case, any events from
     * both calls (replaced and new) will be delivered to the same Call object,
     * where the call ID will be switched back and forth between callbacks.
     * Application must be careful to not destroy the Call object when
     * receiving disconnection event of the replaced call after the transfer
     * process is completed.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallReplaceRequest(OnCallReplaceRequestParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application that an existing call has been replaced with
     * a new call. This happens when PJSUA-API receives incoming INVITE
     * request with Replaces header.
     *
     * After this callback is called, normally PJSUA-API will disconnect
     * this call and establish a new call.
     *
     * If not yet done in onCallReplaceRequest(), application can create
     * the new Call instance and return the Call object via prm.newCall.
     * In creating the new Call instance, the account should use the same
     * account as this call and the call ID must be set to prm.newCallId.
     *
     * If the new Call instance has been setup in onCallReplaceRequest(),
     * the prm.newCall should contain the new Call instance and application
     * MUST not change it.
     *
     * If application does not specify new Call object, library will reuse the
     * existing Call object for callbacks. In this case, any events from
     * both calls (replaced and new) will be delivered to the same Call object,
     * where the call ID will be switched back and forth between callbacks.
     * Application must be careful to not destroy the Call object when
     * receiving disconnection event of the replaced call after the transfer
     * process is completed.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallReplaced(OnCallReplacedParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application when call has received new offer from remote
     * (i.e. re-INVITE/UPDATE with SDP is received). Application can
     * decide to accept/reject the offer by setting the code (default
     * is PJSIP_SC_OK (200)). If the offer is accepted, application can update
     * the call setting to be applied in the answer. When this callback is
     * not implemented, the default behavior is to accept the offer using
     * current call setting.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallRxOffer(OnCallRxOfferParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application when call has received a re-INVITE offer from
     * the peer. It allows more fine-grained control over the response to
     * a re-INVITE. If application sets prm.isAsync to true, it can send
     * the reply manually using the function #pj::Call::answer() and setting
     * the SDP answer. Otherwise, by default the re-INVITE will be
     * answered automatically after the callback returns.
     *
     * Currently, this callback is only called for re-INVITE with
     * SDP, but app should be prepared to handle the case of re-INVITE
     * without SDP.
     *
     * Remarks: If manually answering at a later timing, application may
     * need to monitor onCallTsxState() callback to check whether
     * the re-INVITE is already answered automatically with
     * PJSIP_SC_REQUEST_TERMINATED (487) due to being cancelled.
     *
     * Note: onCallRxOffer() will still be called after this callback,
     * but only if prm.isAsync is false and prm.statusCode is PJSIP_SC_OK
     * (200).
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallRxReinvite(OnCallRxReinviteParam &prm)
    { PJ_UNUSED_ARG(prm); }


    /**
     * Notify application when call has received INVITE with no SDP offer.
     * Application can update the call setting (e.g: add audio/video), or
     * enable/disable codecs, or update other media session settings from
     * within the callback, however, as mandated by the standard (RFC3261
     * section 14.2), it must ensure that the update overlaps with the
     * existing media session (in codecs, transports, or other parameters)
     * that require support from the peer, this is to avoid the need for
     * the peer to reject the offer.
     *
     * When this callback is not implemented, the default behavior is to send
     * SDP offer using current active media session (with all enabled codecs
     * on each media type).
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallTxOffer(OnCallTxOfferParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application on incoming MESSAGE request.
     *
     * @param prm       Callback parameter.
     */
    virtual void onInstantMessage(OnInstantMessageParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application about the delivery status of outgoing MESSAGE
     * request.
     *
     * @param prm       Callback parameter.
     */
    virtual void onInstantMessageStatus(OnInstantMessageStatusParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notify application about typing indication.
     *
     * @param prm       Callback parameter.
     */
    virtual void onTypingIndication(OnTypingIndicationParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * This callback is called when the call is about to resend the
     * INVITE request to the specified target, following the previously
     * received redirection response.
     *
     * Application may accept the redirection to the specified target,
     * reject this target only and make the session continue to try the next
     * target in the list if such target exists, stop the whole
     * redirection process altogether and cause the session to be
     * disconnected, or defer the decision to ask for user confirmation.
     *
     * This callback is optional,
     * the default behavior is to NOT follow the redirection response.
     *
     * @param prm       Callback parameter.
     *
     * @return          Action to be performed for the target. Set this
     *                  parameter to one of the value below:
     *                  - PJSIP_REDIRECT_ACCEPT: immediately accept the
     *                    redirection. When set, the call will immediately
     *                    resend INVITE request to the target.
     *                  - PJSIP_REDIRECT_ACCEPT_REPLACE: immediately accept
     *                    the redirection and replace the To header with the
     *                    current target. When set, the call will immediately
     *                    resend INVITE request to the target.
     *                  - PJSIP_REDIRECT_REJECT: immediately reject this
     *                    target. The call will continue retrying with
     *                    next target if present, or disconnect the call
     *                    if there is no more target to try.
     *                  - PJSIP_REDIRECT_STOP: stop the whole redirection
     *                    process and immediately disconnect the call. The
     *                    onCallState() callback will be called with
     *                    PJSIP_INV_STATE_DISCONNECTED state immediately
     *                    after this callback returns.
     *                  - PJSIP_REDIRECT_PENDING: set to this value if
     *                    no decision can be made immediately (for example
     *                    to request confirmation from user). Application
     *                    then MUST call processRedirect()
     *                    to either accept or reject the redirection upon
     *                    getting user decision.
     */
    virtual pjsip_redirect_op onCallRedirected(OnCallRedirectedParam &prm)
    {
        PJ_UNUSED_ARG(prm);
        return PJSIP_REDIRECT_STOP;
    }
    
    /**
     * This callback is called when media transport state is changed.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallMediaTransportState(OnCallMediaTransportStateParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * Notification about media events such as video notifications. This
     * callback will most likely be called from media threads, thus
     * application must not perform heavy processing in this callback.
     * Especially, application must not destroy the call or media in this
     * callback. If application needs to perform more complex tasks to
     * handle the event, it should post the task to another thread.
     *
     * @param prm       Callback parameter.
     */
    virtual void onCallMediaEvent(OnCallMediaEventParam &prm)
    { PJ_UNUSED_ARG(prm); }
    
    /**
     * This callback can be used by application to implement custom media
     * transport adapter for the call, or to replace the media transport
     * with something completely new altogether.
     *
     * This callback is called when a new call is created. The library has
     * created a media transport for the call, and it is provided as the
     * \a mediaTp argument of this callback. The callback may change it
     * with the instance of media transport to be used by the call.
     *
     * @param prm       Callback parameter.
     */
    virtual void
    onCreateMediaTransport(OnCreateMediaTransportParam &prm)
    { PJ_UNUSED_ARG(prm); }

    /**
     * Warning: deprecated and may be removed in future release.
     * Application can set SRTP crypto settings (including keys) and
     * keying methods via AccountConfig.mediaConfig.srtpOpt.
     * See also ticket #2100.
     *
     * This callback is called when SRTP media transport is created.
     * Application can modify the SRTP setting \a srtpOpt to specify
     * the cryptos and keys which are going to be used. Note that
     * application should not modify the field
     * \a pjmedia_srtp_setting.close_member_tp and can only modify
     * the field \a pjmedia_srtp_setting.use for initial INVITE.
     *
     * @param prm       Callback parameter.
     */
    virtual void
    onCreateMediaTransportSrtp(OnCreateMediaTransportSrtpParam &prm)
    { PJ_UNUSED_ARG(prm); }

private:
    friend class Endpoint;

    Account             &acc;
    pjsua_call_id        id;
    Token                userData;
    std::vector<Media *> medias;
    pj_pool_t           *sdp_pool;
    Call                *child;     /* New outgoing call in call transfer.  */
};

/**
 * @}  // PJSUA2_CALL
 */

} // namespace pj

#endif  /* __PJSUA2_CALL_HPP__ */

