/*
* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* Name          : InviteClientTa.h
* Part of       : Transaction
* Version       : SIP/5.0
*
*/




/**
 @internalComponent
*/

#ifndef INVITECLIENTTA_H
#define INVITECLIENTTA_H

// INCLUDES
#include "ClientTransaction.h"

// FORWARD DECLARATIONS
class CTimerBase;
class CTimerRetransmit;
class CTimerTerminateTa;

// CLASS DECLARATION
/*
 * This class is used for sending INVITE, receiving responses to it and sending
 * ACK.
 */
class CInviteClientTransaction : public CClientTransaction
	{
public: // Constructors and destructor

	/**
	 * Creates a new instance of CInviteClientTransaction	 
	 *
	 * @param aUserAgent UserAgent owning the new transaction being created.
	 * @param aTransmitter CTransmitter used for sending messages
	 * @param aTimers Timer services interface
	 * @param aInitialState Initial state of the CTransaction object
	 * @param aTimerValues Values for calculating timer durations
	 * @param aTransactionStore TransactionStore
	 * @param aRetransmitInvite If ETrue and using UDP, INVITE is retransmitted
	 *		  even after receiving a provisional response.
	 * @return New CInviteClientTransaction object, ownership is transferred
	 */
	static CInviteClientTransaction*
		NewL(CUserAgentBase& aUserAgent,
			 CTransmitter& aTransmitter,
			 MTimerManager& aTimers,
			 CTransactionState& aInitialState,
			 TTimerValues& aTimerValues,
			 MTransactionStore& aTransactionStore,
			 TBool aRetransmitInvite);

	~CInviteClientTransaction();

public: // From CClientTransaction:

	void DeleteTimer(const CTransactionTimer& aTimer);

	TBool IsInviteTransaction() const;

public: // New functions

	/**
	 * Receive a response.
	 *	 
	 * @pre aResponse != NULL
	 *
     * @param aResponse SIP response, ownership is transferred
     * @param aCurrent Transaction's current state
     * @param aCompleted Completed state of transaction state machine
     * @param aTimer If non-NULL, this timer is stopped if leave occurs.
     *		  Ownership is not transferred.
     * @param aTimer2 If non-NULL, this timer is stopped if leave occurs.
     *		  Ownership is not transferred.
	 */
	void ReceiveResponseL(CSIPResponse* aResponse,
						  const CTransactionState& aCurrent,                            
                          const CTransactionState& aCompleted,
                          CTransactionTimer* aTimer=NULL,
                          CTransactionTimer* aTimer2=NULL);

	/**
	 * Send ACK created by transaction to network.
	 *
	 * @post iOutgoingMsg = aAck
	 *
	 * @param aAck ACK request, ownership is transferred.	 
	 */	
	void SendAck(CSIPRequest* aAck);

	/**
	 * Starts timer A.
	 *	 
	 * @pre iTimerA = NULL	 
	 */
	void StartTimerAL();

	/**
	 * Starts timer B, unless it is already running.	 
	 */
	void StartTimerBUnlessExistsL();

	/**
	 * Starts timer D, unless it is already running.
	 */
	void StartTimerDUnlessExistsL();

	/**
	 * Starts timer for waiting a final response in the Proceeding state.
	 *	 
	 * @pre iTimerProceeding = NULL
	 *
	 * @return The new timer, ownership is not transferred
	 */
	CTransactionTimer* StartTimerProceedingL();

	/**
	 * Depending on the value of iRetransmitInvite, starts timer for INVITE
	 * retransmissions to keep NAT binding alive.
	 *
	 * @pre iTimerNAT = NULL
	 *
	 * @return The new timer, ownership is not transferred. NULL if the timer
	 *	was not started.
	 */
	CTransactionTimer* StartTimerNATL();

	/**
	 * Stops timer A.
	 *
	 * @post iTimerA = NULL	 
	 */
	void StopTimerA();

	/**
	 * Stops timer B
	 *
	 * @post iTimerB = NULL	 
	 */
	void StopTimerB();

	/**
	 * Stops timer used in Proceeding state.
	 *	 
	 * @post iTimerProceeding = NULL	 
	 */
	void StopTimerProceeding();
	
	/**
	 * Stops NAT binding keepalive timer.
	 *
	 * @post iTimerNAT = NULL	 
	 */
	void StopTimerNAT();

	static CInviteClientTransaction& Ptr(CTransaction& aTransaction);

private: // Constructor, for internal use

	CInviteClientTransaction(CUserAgentBase& aUserAgent,
							 CTransmitter& aTransmitter,
							 MTimerManager& aTimers,
							 CTransactionState& aInitialState,
							 TTimerValues& aTimerValues,
							 MTransactionStore& aTransactionStore,
							 TBool aRetransmitInvite);

private: // New functions, for internal use

	/**
	 * Creates an ACK request and pushes it to CleanupStack.
	 *
	 * @param aResp SIP response for which the ACK is an acknowledgement
	 * @return ACK request, ownership is transferred
	 */	
	CSIPRequest* MakeAckLC(CSIPResponse& aResp) const;

	/**
	 * Copies information from the INVITE into ACK. Copies Request-URI, From,
	 * Call-ID and the top Via header, that has been completely filled by
	 * ConnectionMgr.
	 *
	 * @param aAck ACK request
	 */
	void CopyHeadersFromInviteToAckL(CSIPRequest& aAck) const;	

	/**
	 * Stops timer D
	 *	 
	 * @post iTimerD = NULL
	 */
	void StopTimerD();

	/**
	 * Stops all timers of this transaction
	 *
	 * @post iTimerA = NULL, iTimerB = NULL, iTimerD = NULL	 
	 */
	void CancelAllTimers();

private: // Data

	//Tells if transaction owns the SIP request in CTransaction::iOutgoingMsg.
	//Value is normally EFalse. Only when CInviteClientTransaction (instead of
	//UAC) creates ACK and puts it to CTransaction::iOutgoingMsg, the value is
	//ETrue.
	TBool iTaOwnsRequest;

	//Duration (ms) of timer A
	TUint iTimerADuration;

	//Retransmission timer
	CTimerRetransmit* iTimerA;

	//Transaction timeout timer
	CTimerTerminateTa* iTimerB;

	//Timer used to stop transaction waiting from response retransmissions in
	//the Completed state
	CTimerTerminateTa* iTimerD;

	//Timer used to stop transaction if no final response is received in
	//Proceeding state
	CTimerTerminateTa* iTimerProceeding;

	//If ETrue and using unreliable transport, INVITE is retransmitted even
	//after receiving a provisional response, to keep the NAT binding alive.
	TBool iRetransmitInvite;

	//Retransmission timer to keep NAT binding alive.
	CTimerRetransmit* iTimerNAT;

	//Error code that will be passed while starting the Timer D
	TInt iDTimerErrCode;

private: // For testing purposes

	void __DbgTestInvariant() const;


#ifdef CPPUNIT_TEST
	friend class CTransactionUser_Test;
	friend class CInviteCTa_Calling_Test;
	friend class CInviteCTa_Completed_Test;
#endif
	};

#endif // end of INVITECLIENTTA_H

// End of File