/*

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

* Part of       : TransactionUser

* Version       : SIP/5.0

*

*/

/**

 @internalComponent

*/

#ifndef CTRANSACTIONUSER_H

#define CTRANSACTIONUSER_H

// INCLUDES

#include <e32base.h>

#include <bamdesca.h>

#include <stringpool.h>

#include <commsdattypesv1_1.h>

#include "sipinternalstates.h"

#include "MTransactionUser.h"

#include "MServerTaFactory.h"

#include "MConnectionStateObserver.h"

// FORWARD DECLARATIONS

class MSIPRequestRouter;

class MTimerManager;

class CSipConnectionMgr;

class MSipDialogs;

class MSipRegistrations;

class MSipRegistrationContact;

class CDeleteMgr;

class CSIPSec;

class CTransactionMgr;

class MTransactionOwner;

class CTransactionStore;

class CUserAgent;

class CCancelUAC;

class CUserAgentCreateParams;

class CTimerValueRetriever;

class CSIPMessageUtility;

class CInviteUAC_Start;

class CInviteUAC_ResolveAddress;

class CInviteUAC_WaitResponse;

class CInviteUAC_WaitAckFromApp;

class CInviteUAC_ResolveAckAddress;

class CInviteUAC_SendingAck;

class CInviteUAC_WaitTransactionToEnd;

class CInviteUAC_WaitAuthentication;

class CNormalUAC_Start;

class CNormalUAC_ResolveAddress;

class CNormalUAC_WaitResponse;

class CNormalUAC_WaitAuthentication;

class CInviteUAS_Start;

class CInviteUAS_GetTxOwner;

class CInviteUAS_WaitRespFromApp;

class CInviteUAS_Accepted;

class CInviteUAS_Rejected;

class CNormalUAS_Start;

class CNormalUAS_GetTxOwner;

class CNormalUAS_WaitRespFromApp;

class CNormalUAS_FinalRespSent;

class CCancelUAC_Start;

class CCancelUAC_ResolveAddress;

class CCancelUAC_WaitResponse;

class CCancelUAC_WaitAuthentication;

class CCancelUAS_Start;

class CCancelUAS_FinalRespSent;

// CLASS DECLARATION

/**

 * CTransactionUser class is the interface for using TransactionUser subsystem.

 */

class CTransactionUser :	

	public CBase,

    public MTransactionUser,

	public MServerTaFactory,

    public MConnectionStateObserver

	{

public: // Constructors and destructor

	/**

	 * Creates TransactionUser subsystem.

	 *

	 * @pre aRouter != NULL, aTimers != NULL

	 *

	 * @param aRouter Router interface. Ownership isn't transferred.

	 * @param aTimers Lwtimer interface. Ownership isn't transferred.

	 * @param aObserver Callback to pass connection state information

	 * @return value New CTransactionUser object, ownership is transferred.

	 */	

	static CTransactionUser* NewL(MSIPRequestRouter* aRouter,

							      MTimerManager* aTimers,

								  MConnectionStateObserver& aObserver);

	/**

	 * Destructor. All existing transactions are immediately stopped.

	 */

	~CTransactionUser();

public : // From MTransactionUser

	void SendL(TTransactionId& aTransactionId,

	           TRegistrationId aRegistrationId,

               CSIPRequest* aRequest,

               MTransactionOwner* aObserver,

               CURIContainer& aRemoteTarget,

               const TSIPTransportParams& aTransportParams,

               TBool aDeleteRequest);

	MTransactionHeaders* SendAndGetHeadersL(

						TTransactionId& aTransactionId,

						TRegistrationId aRegistrationId,

						CSIPRequest* aRequest,

						MTransactionOwner* aObserver,						

                        CURIContainer& aRemoteTarget,

                        const TSIPTransportParams& aTransportParams,

						TBool aDeleteRequest);

	void SendL(TTransactionId aTransactionId,

	           CSIPResponse* aResponse,

	           const TSIPTransportParams& aTransportParams) const;

	void SendL(TTransactionId aTransactionId,

	           CSIPResponse* aResponse,

	           MTransactionOwner* aObserver,

	           const TSIPTransportParams& aTransportParams) const;

	void SendCancelL(TTransactionId aInviteTaId,

					 TTransactionId& aCancelTaId,

					 MTransactionOwner* aObserver);

	TInt ClearTransactionOwner(TTransactionId aTransactionId) const;

	TInt ClearTransactionOwner(MTransactionOwner* aObserver) const;

    void GetLocalAddress(TUint32 aIapId, TInetAddr& aAddr) const;

	void FreeResources(MSIPNATBindingObserver& aSIPNATBindingObserver );

	MTransactionHeaders*

        TransactionHeadersL(TTransactionId aTransactionId) const;

	void MakeTagL(TDes8& aTag) const;

	virtual TInt NextHopIP(

		const TTransactionId& aTransactionId, TInetAddr& aAddr);

public: // From MServerTaFactory

	virtual MReceiverObserver*

        NewTransactionL(CSIPRequest& aRequest,

                        const TSIPTransportParams& aParams,

						TTransactionId& aTransactionId);

public: // From MConnectionStateObserver

	void ConnectionStateChangedL(TUint32 aIapId, CSIPConnection::TState aState);

public: // New functions

    /**

 	 * Returns a reference to SIPSec. 

	 *

	 * @returns SIPSec

	 */

    CSIPSec& SIPSec();

    /**

 	 * Returns a reference to SIP ConnnectionMgr.

	 *

	 * @returns ConnectionMgr

	 */    

    CSipConnectionMgr& SipConnectionMgr();

	/**

	 * Gives the address of SIP Dialogs subsystem to TransactionUser subsystem.	 

	 *

	 * @pre aSipDialogs != NULL

	 *

	 * @param aSipDialogs IN: address of SIP Dialogs subsystem. Ownership isn't

	 *	transferred

	 */

	void SetDialogs(MSipDialogs* aSipDialogs);

	/**

	 * Gives the interfaces of SIP Registrations subsystem for TransactionUser

	 * subsystem.

	 *

	 * @pre aSipRegistrations != NULL, aRegistrationContact != NULL

	 *

	 * @param aSipRegistrations IN: interface for checking AORs. Ownership

     *  isn't transferred

	 * @param aRegistrationContact IN: interface for obtaining Contact header.

	 *	Ownership isn't transferred

	 */

	void SetRegistrations(MSipRegistrations* aSipRegistrations,

						  MSipRegistrationContact* aRegistrationContact);        

    /**

	 * Obtains the state of the specified transaction.

	 *

	 * @param aTransactionId TransactionId of the transaction whose state is

     *  requested.

	 * @param aState OUT: Transaction state

	 * @leave KErrNotFound if no such transaction exists.

	 */

    void GetStateL(TTransactionId aTransactionId,

                   CSIPInternalStates::TState& aState) const;

private: // Constructors, for internal use

	CTransactionUser(MSIPRequestRouter* aRouter,

                     MTimerManager* aTimers,

                     MConnectionStateObserver& aStateObserver);

	void ConstructL();

private: // New functions, for internal use

	/**

	 * Builds UA state machines by creating the state objects and linking them

	 * together.

	 */

	void ConstructUaStateMachinesL();

	/**

	 * Generate a new value to be used as a CSeq sequence number.

	 *

	 * @return value Sequence number

	 */

	TUint32 NewCSeqValue();

	/**

	 * Fills the common parameters for creating a new UA.	 

	 *

	 * @param aTransactionId Transaction id for the new UserAgent

	 * @param aObserver Callback to the upper layer. Can be NULL. Ownership

	 *	isn't transferred.

	 * @param aDeleteOutgoingMsg If ETrue, UserAgent deletes iOutgoingMsg when

	 *	UserAgent itself is deleted.

     * @param aParams IN: Transport parameters to be used when handing a SIP

     *					  message to SIP Connection Mgr.

	 * @return Object containing the common parameters for all UserAgent types.

	 *	Ownership is transferred.

	 */

	CUserAgentCreateParams* FillUserAgentParamsLC(TTransactionId aTransactionId,

									  MTransactionOwner* aObserver,

									  TBool aDeleteOutgoingMsg,

			                          const TSIPTransportParams& aParams) const;

	/**

	 * Creates an UAS for handling a SIP request received from network.

	 *

	 * @param aTaId TransactionId for the UAS

	 * @param aMethod Method of the SIP request

     * @param aParams IN: Transport parameters to be used when handing a SIP

     *					  message to SIP Connection Mgr.

	 * @return value New UA object, ownership is transferred

	 */

	CUserAgent* CreateUasL(TTransactionId aTaId,

						   RStringF aMethod,

                           const TSIPTransportParams& aParams) const;

	/**

	 * Creates an UAC for sending a new SIP request to network.	 

	 *

	 * @param aTaId TransactionId for the UAC

	 * @param aMethod Method of the SIP request

	 * @param aObserver Callback where UAC sends the response and other events

	 * @param aDeleteRequest If ETrue, UAC will delete the SIP request when UAC

	 *	ends. If EFalse, UAC doesn't delete the SIP request. In either case,

	 *  UAC can modify the request.

	 * @param aCSeqNumber CSeq sequence number for UAC to use, unless filled by

	 *	upper layer.

     * @param aParams IN: Transport parameters to be used when handing a SIP

     *					  request to SIP Connection Mgr.

	 * @return value New UA object, ownership is transferred

	 */

	CUserAgent* CreateUacL(TTransactionId aTaId,

						   RStringF aMethod,

						   MTransactionOwner& aObserver,

						   TBool aDeleteRequest,

						   TUint32 aCSeqNumber,

                           const TSIPTransportParams& aParams) const;

    /**

	 * Creates UAC for sending CANCEL request to network.

	 *	 

	 * @param aTaId TransactionId for the UAC	 

	 * @param aObserver Callback where UAC sends the response an other events	 

     * @param aCSeqNumber CSeq sequence number for UAC to use, unless filled by

	 *	upper layer.

	 * @param aParams IN: Transport parameters to be used when handing a SIP

     *					  request to SIP Connection Mgr.

	 * @return value New CancelUAC object, ownership is transferred

	 */

    CCancelUAC*

    	CreateCancelUacL(TTransactionId aTaId,

						 MTransactionOwner& aObserver,

                         TUint32 aCSeqNumber,

                         const TSIPTransportParams& aParams) const;

    /**

     * Returns the Timer Retriever Mapped bearer type

     * @param aIapID IapID for which bearer type needs to be determined 

     */

    TInt TimerRetrieverMappedBearerTypeL(TUint32 aIapID) const;

private: // Data

	//Determines where incoming requests are routed. Not owned.

	MSIPRequestRouter* iRouter;

	//Timer services. Not owned.

	MTimerManager* iTimers;

    //Connection state changes are reported to this callback

	MConnectionStateObserver& iStateObserver;

	//Dialog subsystem. Not owned.

	MSipDialogs* iDialogs;

	//Registration subsystem. Not owned.

	MSipRegistrations* iRegistrations;

	//Used for filling in information to Contact-headers of outgoing SIP

    //messages. Not owned.

	MSipRegistrationContact* iRegistrationContact;

	//Transport layer. Owned.

	CSipConnectionMgr* iConnectionMgr;

	//Contains information of all existing transactions and UAs. Owned.

	CTransactionStore* iTransactionStore;

	//Used for freeing memory asynchronously. Owned.

	CDeleteMgr*	iDeleteMgr;	

	//There is one instance of each UA state object. They're all owned.

	//Invite user agent client states

	CInviteUAC_Start*				 iInviteUAC_Start;

	CInviteUAC_ResolveAddress*		 iInviteUAC_ResolveAddress;

	CInviteUAC_WaitResponse*		 iInviteUAC_WaitResponse;

	CInviteUAC_WaitAckFromApp*		 iInviteUAC_WaitAckFromApp;

	CInviteUAC_ResolveAckAddress*	 iInviteUAC_ResolveAckAddress;

	CInviteUAC_SendingAck*			 iInviteUAC_SendingAck;

	CInviteUAC_WaitTransactionToEnd* iInviteUAC_WaitTransactionToEnd;

	CInviteUAC_WaitAuthentication*	 iInviteUAC_WaitAuthentication;	

	//Non-Invite user agent client states

	CNormalUAC_Start*				iNormalUAC_Start;

	CNormalUAC_ResolveAddress*		iNormalUAC_ResolveAddress;

	CNormalUAC_WaitResponse*		iNormalUAC_WaitResponse;

	CNormalUAC_WaitAuthentication*	iNormalUAC_WaitAuthentication;	

	//Cancel user agent client states

	CCancelUAC_Start*				iCancelUAC_Start;

	CCancelUAC_ResolveAddress*		iCancelUAC_ResolveAddress;

	CCancelUAC_WaitResponse*		iCancelUAC_WaitResponse;

	CCancelUAC_WaitAuthentication*	iCancelUAC_WaitAuthentication;

	//Invite user agent server states

	CInviteUAS_Start*			iInviteUAS_Start;

	CInviteUAS_GetTxOwner*		iInviteUAS_GetTxOwner;

	CInviteUAS_WaitRespFromApp* iInviteUAS_WaitRespFromApp;

	CInviteUAS_Accepted*		iInviteUAS_Accepted;

	CInviteUAS_Rejected*		iInviteUAS_Rejected;

	//Non-Invite user agent server states

	CNormalUAS_Start*			iNormalUAS_Start;

	CNormalUAS_GetTxOwner*		iNormalUAS_GetTxOwner;

	CNormalUAS_WaitRespFromApp* iNormalUAS_WaitRespFromApp;

	CNormalUAS_FinalRespSent*	iNormalUAS_FinalRespSent;	

	//Cancel user agent server states

	CCancelUAS_Start*			iCancelUAS_Start;

	CCancelUAS_FinalRespSent*	iCancelUAS_FinalRespSent;

	//Counter used to produce CSeq numbers for outgoing requests when the upper

	//layers have not filled the CSeq number.	

	TUint32 iCSeqCounter;

	//Transaction layer. Owned.

	CTransactionMgr* iTransactionMgr;

	//Timer values, owned.

	CTimerValueRetriever* iTimerValueRetriever;

    //SIP message manipulating utilities. Owned.

	CSIPMessageUtility* iSIPMsgUtility;

	//SIP Security subsystem. Owned.

	CSIPSec* iSIPSec;

private: // For testing purposes

#ifdef CPPUNIT_TEST

	friend class CTransactionUser_Test;

#endif

	void __DbgTestInvariant() const;

	};

#endif // end of CTRANSACTIONUSER_H

// End of File