/*

* 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          : ClientTransaction.h

* Part of       : Transaction

* Version       : SIP/5.0

*

*/

/**

 @internalComponent

*/

#ifndef CLIENTTRANSACTION_H

#define CLIENTTRANSACTION_H

// INCLUDES

#include "CTransaction.h"

// FORWARD DECLARATIONS

class CDeleteMgr;

class MTransactionStore;

// CLASS DECLARATION

/*

 * This class represents a client transaction. It is created for handling an

 * outgoing SIP request message and the SIP response message associated with it.

 */

class CClientTransaction : public CTransaction

	{

public: // Destructor

	~CClientTransaction();

public:	// From CTransaction

	void IcmpErrorL(const TInetAddr& aAddress,

				    CSipConnectionMgr::TICMPError aError);

	virtual void DeleteTimer(const CTransactionTimer& aTimer) = 0;

	/**

	 * ClientTransaction enters terminated state. If transaction has been

	 * detached from the UAC, it uses DeleteMgr to free itself.

	 *

	 * @param aReason Reason why ClientTransaction ends	 

	 */

	void TerminatedL(TInt aReason);

	/**

	 * Sends the SIP request in the send buffer (iOutgoingMsg) to CTransmitter.

	 *

	 * CClientTransaction passes a reference to the iOutgoingMsg for the

	 * CTransmitter, which in turn gives a reference to the request for the

	 * ConnectionMgr.

     *

	 * UAC owns the request, unless it is an ACK created by

	 * CInviteClientTransaction instead of UAC.

	 *

	 * @pre iOutgoingMsg != NULL, iTransmitter isn't active

	 */

	void SendToTransmitterL();

private: // From CTransaction

	virtual void CancelAllTimers() = 0;

public: // New functions

	TTransactionId TransactionId() const;

	/**

	 * Stores SIP request and related parameters.

	 *

	 * @pre !iOutgoingMsg && !iOutboundProxy

	 *

	 * @param aReq SIP request

	 * @param aAddress Address where the request will be sent to

	 * @param aParams Transport parameters to use when sending the SIP request	 

	 * @param aTransportProtocol The transport protocol used for sending

	 * @param aForceUDP ETrue if transport protocol can't be changed from UDP

	 * @param aOutboundProxy Outbound proxy, NULL pointer if not used.

     *        The ownership is transferred.

	 */

	void StoreRequest(CSIPRequest& aReq,

					  const TInetAddr& aAddress,

					  const TSIPTransportParams& aParams,

					  RStringF aTransportProtocol,

					  TBool aForceUDP,

					  CUri8* aOutboundProxy);

	/**

	 * Clears, but does not delete, the outbound proxy.

	 *

	 * @post iOutboundProxy == NULL	 

	 */

	void ClearProxy();

	/**

	 * Filter out retransmissions and invalid SIP responses.

	 *

	 * @param aResp Received SIP response

	 * @return ETrue: Transaction will handle the response, ownership of aResp

	 *	isn't transferred.

	 *	EFalse: Response is dropped, ownership of aResp has been transferred.

	 */

	TBool ShouldTaHandleResponse(CSIPResponse* aResp) const;

    /**

	 * Forwards the SIP response to UAC.

	 *

	 * @pre iUserAgent != NULL, aResp != NULL

	 *

	 * @param aResp SIP response, ownership is transferred	 

	 */

	void PassResponseToUserAgentL(CSIPResponse* aResp);

	/**

	 * CTransaction will run independently of UAC.

	 *

	 * CNormalClientTransaction absorbs response retransmissions.

	 *

	 * CInviteClientTransaction sends ACK to a non-2xx response by itself, and

	 * takes ownership of CTransaction::iTransmitter.

	 *

	 * @param aTransactionId TransactionId that CTransaction will use to

	 *	remove its information from MTransactionStore

	 * @param aDeleteMgr DeleteMgr to use to free the transaction when it

	 *  terminates. Ownership isn't transferred.

	 * @param aClearTransmitter If ETrue, transaction detaches itself from

	 *	CTransmitter and clears its pointer to it.

	 */

	void RunIndependently(TTransactionId aTransactionId,

						  CDeleteMgr* aDeleteMgr,

						  TBool aClearTransmitter);	

	/**

	 * Check if ConnectionMgr has changed the transport protocol in the top

	 * Via header from the value that transaction used. If transport changes,

	 * it affects some transaction timers.	 

	 */

	void CheckForTransportChange();	

protected:

	/**

	 * Constructor

	 *

	 * @param aUserAgent UAC owning the new transaction being created.

	 * @param aTransmitter CTransmitter for sending requests

	 * @param aTimers Timer services

	 * @param aInitialState Initial state of the transaction

	 * @param aTimerValues Values for calculating timer durations

	 * @param aTransactionStore TransactionStore

	 */

	CClientTransaction(CUserAgentBase& aUserAgent,

					   CTransmitter& aTransmitter,

					   MTimerManager& aTimers,

					   CTransactionState& aInitialState,

					   TTimerValues& aTimerValues,

					   MTransactionStore& aTransactionStore);

	/**

	 * Check whether the received SIP response is ok.

	 *

	 * @param aResp SIP response

	 * @return value ETrue  the response is ok,

	 *	             EFalse otherwise

	 */

	TBool CheckReceivedResponse(CSIPResponse& aResp) const;

protected: // Data

	//Used for deleting CClientTransaction if it has been detached from the UAC.

	//This is non-NULL only when UAC decided to send the request again, using

	//another transaction instance.

	//If iDeleteMgr is non-NULL, CInviteClientTransaction owns the

	//CTransaction::iTransmitter.

	CDeleteMgr*	iDeleteMgr;

private: // Data

	//The response code of the most recently received SIP response. Used to

    //filter the retransmissions from being sent to UserAgent.

	TUint iReceivedResponseCode;

	//Address where the SIP request is sent. Obtained from UserAgent and

	//stored here for retransmissions.

	TInetAddr iRemoteAddr;

	//ETrue if transport protocol can't be changed from UDP

	TBool iForceUDP;

    //iTransactionId and iTransactionStore are needed by a detached transaction

    //when UserAgent has created another transaction to send an updated request.

	//Identifies the transaction

	TTransactionId iTransactionId;

	//A detached transaction must remove its information from MTransactionStore

	//when terminating, since UAC is attached to the new transaction, and no

	//longer to the old transaction(s).

	MTransactionStore& iTransactionStore;

	//Outbound proxy, or NULL if proxy is not used. Owned.

	CUri8* iOutboundProxy;

private: // For testing purposes

	void __DbgTestInvariant() const;

#ifdef CPPUNIT_TEST

	friend class ClientTransaction_Test;

	friend class CNormalCTa_Trying_Test;

	friend class CTransactionUser_Test;

	friend class CInviteCTa_Calling_Test;

#endif

	};

#endif // end of CLIENTTRANSACTION_H

// End of File