/*

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

* Part of       : Transaction

* Version       : SIP/5.0

*

*/

/**

 @internalComponent

*/

#ifndef CTRANSACTION_H

#define CTRANSACTION_H

// INCLUDES

#include <stringpool.h>

#include "SipStackServerDefs.h"

#include "SipLogs.h"    //for USE_SIP_LOGS

#include "Lwtimer.h"

#include "SendStatus.h"

#include "TSIPTransportParams.h"

#include "TimerValues.h"

#include "TransactionBase.h"

#include "sip.h"

// FORWARD DECLARATIONS

class CSIPMessage;

class CTransmitter;

class CUserAgentBase;

class CTransactionState;

class TTimerValues;

class CTransactionTimer;

// CLASS DECLARATION

/*

 * The base class for all transactions.

 */

class CTransaction :

	public CTransactionBase,

	public MExpirationHandler,

	public MSendStatus

	{

public: // Destructor

	~CTransaction();

public:	// From CTransactionBase

    void ReceiveL(CSIPRequest* aRequest);

	void ReceiveL(CSIPResponse* aResponse);

	void LeaveOccurred(TInt aReason);

	const TSIPTransportParams& TransportParams() const;

	virtual void IcmpErrorL(const TInetAddr& aAddress,

							CSipConnectionMgr::TICMPError aError) = 0;

	void SendRequestL(CSIPRequest& aReq,

					  const TInetAddr& aAddress,					  

					  RStringF aProtocol,

					  TBool aForceUDP,

					  const TSIPTransportParams& aParams,

					  CUri8* aOutboundProxy);

	void SendResponseL(CSIPResponse* aResp,					   

					   RStringF aProtocol,

					   const TSIPTransportParams& aParams);

	TBool ClearSendBuffer();

    void GetState(CSIPInternalStates::TState& aState);

	void Terminated();

	virtual void TerminatedL(TInt aReason);

	TBool HasTerminated() const;

	void DetachFromUserAgent();

	RStringF TransportProtocol() const;

public: // From MExpirationHandler

	void TimerExpiredL(TTimerId aTimerId, TAny* aTimerParam);

public:	// From MSendStatus

	void SendCompleteL();

	void SendFailedL(TInt aError);

	void LeaveFromTransmitter(TInt aReason);

public: // New pure virtual functions

	/**

	 * Delete the Transaction specific timer. Each separate transaction type

	 * has different timers. If this transaction has a matching timer, the

	 * timer will be deleted.

	 *

	 * @param aTimer Timer to be deleted

	 */

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

	/**

	 * Sends a SIP message to CTransmitter.

	 *

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

	 */

	virtual void SendToTransmitterL() = 0;	

protected: // New pure virtual functions

	/**

	 * Stops transactions's all timers.

	 */

	virtual void CancelAllTimers() = 0;

public: // New functions

	/**

	 * Tells if the transaction is an INVITE (client/server) transaction or a

	 * non-INVITE (client/server) transaction.

	 *

	 * @return ETrue if INVITE transaction, EFalse otherwise.

	 */

	virtual TBool IsInviteTransaction() const;

	/**

	 * Transaction enters a new state

	 *

	 * @param aNewState State which CTransaction enters	 

	 */

	void ChangeState(const CTransactionState& aNewState);	

	/**

	 * Sets the iTransportProtocol member according to the transport protocol

	 * in the top Via header of the aMsg.

	 *

	 * @param aMsg SIP message

	 * @return value ETrue: if successful, EFalse: otherwise

	 */

	TBool UpdateTransportProtocol(CSIPMessage& aMsg);

	/**	

	 * Checks if transaction is using unreliable transport.

	 *

	 * @return ETrue if an unreliable transport is used, EFalse otherwise

	 */	

	TBool IsUnreliableTransportUsed() const;

    /**	

	 * Checks if the CTransmitter is currently sending.

	 *	 

	 * @return ETrue: CTransmitter is sending, EFalse: otherwise

	 */	

	TBool IsTransmitterSending() const;

	/**	

	 * Returns a pointer to the current state.

	 *

	 * @return Transaction's current state, ownership isn't transferred.

	 */	

	const CTransactionState* State() const;

protected:

	/**

	 * Constructor

	 *

	 * @pre aTransmitter != NULL, aInitialState != NULL

	 *

	 * @param aUserAgent UserAgent owning the new CTransaction being created.

	 * @param aTransmitter CTransmitter used for sending messages.

	 * @param aTimers LwTimer subsystem

	 * @param aInitialState Initial state of the CTransaction object

	 * @param aTimerValues Values for calculating timer durations

	 */

	CTransaction(CUserAgentBase& aUserAgent,

				 CTransmitter& aTransmitter,

				 MTimerManager& aTimers,

				 CTransactionState& aInitialState,

				 TTimerValues& aTimerValues);

	/**

	 * Obtains the id of the transaction.

	 *

	 * @return TransactionId of the transaction

	 */

	virtual TTransactionId TransactionId() const;

protected: // Data:

	//UserAgent associated with this transaction. Can be NULL. Not owned.

	CUserAgentBase* iUserAgent;

	//CTransmitter used for sending messages, owned by UserAgent.

	//In a special case the CInviteClientTransaction can own the CTransmitter.

	CTransmitter* iTransmitter;

	//Timer subsystem

	MTimerManager& iTimers;

	//Outgoing SIP message.

	//

	//In case of ClientTransaction, UAC owns the message, except when

	//InviteClientTransaction has created the ACK (instead of UAC creating the

	//ACK).

	//

	//In case of ServerTransaction, CTransaction owns the message. Except if

	//InviteServerTransaction is sending a 2xx response, when the UAS owns it.	

	CSIPMessage* iOutgoingMsg;

	RStringF iTransportProtocol;

	//Transport parameters to be used when sending the SIP message

	TSIPTransportParams iTransportParams;

	//Copy of the values in CTimerValueRetriever::TTimerValues, at the time the

	//transaction was created. Later changes to

	//CTimerValueRetriever::TTimerValues won't reflect here.

	TTimerValues iTimerValues;

	//ETrue when CTransaction has reached terminated state.

	//There is no separate state object for the terminated state.

	TBool iTerminated;

private:

#if defined(USE_SIP_LOGS)

	/**

	 * Write the transaction state to a log file.

	 *

	 * @param aState Transaction state

	 */	

	void WriteStateToLog(const CTransactionState& aState) const;

#endif

private: // Data

	//Current state of the transaction FSM, not owned.

	const CTransactionState* iState;

	void __DbgTestInvariant() const;

#ifdef CPPUNIT_TEST

	friend class CTransactionUser_Test;

	friend class ClientTransaction_Test;

	friend class CServerTransaction_Test;

	friend class CInviteServerTa_Test;

	friend class CNormalCTa_Trying_Test;

	friend class CNormalCTa_Proceeding_Test;

	friend class CNormalCTa_Completed_Test;

	friend class CNormalSTa_Trying_Test;

	friend class CNormalSTa_Proceeding_Test;

	friend class CNormalSTa_Completed_Test;

	friend class CNormalUAS_GetTxOwner_Test;

	friend class CNormalUAS_Start_Test;

	friend class CUserAgentClient_Test;

	friend class CUserAgentServer_Test;

	friend class CInviteCTa_Calling_Test;

#endif

	};

#endif // end of CTRANSACTION_H

// End of File