/*
* 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          : InviteUAC.h
* Part of       : TransactionUser
* Version       : SIP/5.0
*
*/




/**
 @internalComponent
*/

#ifndef INVITEUAC_H
#define INVITEUAC_H

// INCLUDES
#include "UserAgentClient.h"

// FORWARD DECLARATIONS
class CTimerStopUA;
class CTimerAsyncSIPSec;


// CLASS DECLARATION

class CInviteUAC : public CUserAgentClient
	{
public: // Constructor and destructor

	/**
	 * Creates a new CInviteUAC instance.
	 *
	 * @param aParams UA parameters
	 * @param aConnectionMgr ConnectionMgr used for sending
	 * @param aResolver For resolving URI
	 * @param aSIPSec SIP security subsystem
	 * @param aCSeqNumber CSeq value to put into INVITE if CSeq was not filled
	 *		  by upper layers.
	 * @param aIsPrivateAddress ETrue if the local address is in IPv4 private
	 *		  address space. EFalse otherwise.
	 * @param aAckSenderState The starting state of the FSM of InviteUACs that
	 *		  send the additional ACK requests to network.
	 * @return New object, ownership is transferred.
	 */
	static CInviteUAC* NewL(CUserAgentCreateParams& aParams,
                            MSipConnectionMgr& aConnectionMgr,
                            MSipUriResolver& aResolver,
							CSIPSec& aSIPSec,
							TUint32 aCSeqNumber,
							TBool aIsPrivateAddress,							
							CUserAgentState* aAckSenderState);

	~CInviteUAC();

public: // From CUserAgentClient

	void ReceiveResponseL(CSIPResponse* aResp,
						  const CUserAgentState& aResolve,
						  const CUserAgentState& aWaitResponse,
						  const CUserAgentState& aWaitAckFromApp,
						  const CUserAgentState& aWaitTransactionToEnd);						  

	/**
     * A new CTransmitter instance is created for InviteUAC and it's new
     * transaction. Ownership of the current CTransmitter is passed to the old
     * transaction. Two separate CTransmitter instances are needed to allow
     * both the old and new CInviteClientTransaction to send messages
     * simultaneously.
	 *
     * @param aNewTransactionId TransactionId that is given to the old
     *  transaction.
	 */
    void PrepareTxForNewRequestL(TTransactionId& aNewTransactionId);

private: // From CUserAgentClient

	void CreateTransactionL();
	
public: // From CUserAgent

    void ClearTransactionOwner();

	void DeleteTimer(const CUserAgentTimer& aTimer);

	TBool IsInviteUAC() const;

	TBool IsSubInviteUAC() const;	

public: // New functions

	/**
	 * Checks if the InviteUAC has been canceled.
	 *
	 * @return ETrue: InviteUAC has been canceled, EFalse: otherwise
	 */	
	TBool IsCanceled() const;

	/**
	 * Start a timer to cause the processing of a response to go asynchronous,
	 * also now that SIPSec processed the response synchronously.
	 */
	void StartSIPSecTimerL();

	/**
	 * Send ACK request.
	 *
	 * @param aAck ACK request. Parameter aDeleteRequest determines whether the
	 *	ownership of aAck is transferred.
	 * @param aObserver IN: Callback to upper layer.
	 * @param aParams Transport parameters to be used for sending the ACK
	 * @param aRegisterId Identifies the registration whose outbound proxy may
	 *	be used.
	 * @param aRemoteTarget Remote target of the ACK
	 * @param aDeleteRequest If ETrue, ownership of aAck is transferred.
	 * @param aBranch The branch value to put into the ACK. If this is an empty
	 *		  string, a new branch is generated.
	 */
	void SendAckL(CSIPRequest* aAck,
				  MTransactionOwner& aObserver,
				  const TSIPTransportParams& aParams,
				  TRegistrationId aRegisterId,
				  const CURIContainer& aRemoteTarget,
				  TBool aDeleteRequest,
				  RStringF aBranch);

	/**
	 * The first ACK to a 2xx is sent.
	 *
	 * @param aAck ACK request. Parameter aDeleteRequest determines whether the
	 *	ownership of aAck is transferred.
	 * @param aObserver	IN: Callback to upper layer.
	 * @param aParams Transport parameters to be used for sending the ACK
	 * @param aRegisterId Identifies the registration whose outbound proxy may
	 *	be used.
	 * @param aRemoteTarget Remote target of the ACK
	 * @param aDeleteRequest If ETrue, ownership of aAck is transferred.
	 * @param aBranch The branch value to put into the ACK. If this is an empty
	 *		  string, a new branch is generated.
	 */
	void SendFirstAckL(CSIPRequest* aAck,
					   MTransactionOwner& aObserver,
					   const TSIPTransportParams& aParams,
					   TRegistrationId aRegisterId,
					   const CURIContainer& aRemoteTarget,
					   TBool aDeleteRequest,
					   RStringF aBranch);

	/**
	 * The Invite client transaction is canceled. If InviteUAC doesn't receive
	 * a final response, it ends with a reason KErrCancel.	 
     */	
    void CancelInvite();

    /**
	 * Route headers are copied from INVITE to the CANCEL.
	 *	 
	 * @pre iOutgoingMsg != NULL
	 *
	 * @param aCancel IN/OUT: CANCEL request
     */	
    void CopyRouteHeadersToCancelL(CSIPRequest& aCancel);

	void HandleIcmpErrorL(const TInetAddr& aAddress,
						  const CUserAgentState& aResolveAckAddress,
						  const CUserAgentState& aWaitResponse);	

	/**
	 * Checks that the ACK contains all the necessary information for TU to
     * send it. If it doesn't function leaves.
	 *
	 * @param aAck ACK message	 
	 */	
	void CheckAckL(CSIPRequest& aAck) const;

	/**
	 * Fills the ACK.
	 *
	 * @param aAck ACK request
	 * @param aBranch The branch value to put into the ACK. If this is an empty
	 *		  string, a new branch is generated.
	 */
	void FillAckL(CSIPRequest& aAck, RStringF aBranch);

	/**
	 * The remote address for ACK has been resolved. UserAgent will send the
	 * ACK to the first address received from ServerResolver.	 
	 */
	void AckAddressResolvedL();

	/**
	 * Send another ACK, after at least one ACK has already been sent.
	 * UAC has to resolve the remote address for every ACK, so it creates a
	 * CAckHandler object for resolving and sending all the subsequent ACKs
	 * from the upper layer, after the first ACK. UAC handles the first ACK
	 * from upper layer by itself.
	 *
	 * @param aAck ACK message
	 * @param aObserver IN: Callback to upper layer.
	 * @param aParams Transport parameters to be used for sending the ACK
	 * @param aRegisterId Registration id to get outbound proxy
	 * @param aRemoteTarget Remote target
	 * @param aDeleteRequest If ETrue, CAckHandler will delete aAck when it
	 *	ends. If EFalse, aAck is freed by the upper layer.
	 */		
	void SendAdditionalAckL(CSIPRequest* aAck,
						    MTransactionOwner& aObserver,
							const TSIPTransportParams& aParams,
							TRegistrationId aRegisterId,
							const CURIContainer& aRemoteTarget,
							TBool aDeleteRequest);

	/**
	 * UAC receives another 2xx, which is either a retransmission, or 2xx from
	 * another endpoint with a different To-tag. In either case, the 2xx is
	 * passed to upper layer which will (re)send the ACK.		
	 *
	 * @pre aResp != NULL
	 *
	 * @param aResp 2xx response, ownership is transferred.
	 */
	void HandleAdditional2xxL(CSIPResponse* aResp);

	static CInviteUAC& Ptr(CUserAgent& aUserAgent);
	
	void SetSipSecError(TInt aErr);

private:

	CInviteUAC(CUserAgentCreateParams& aParams,
               MSipConnectionMgr& aConnectionMgr,
               MSipUriResolver& aResolver,
			   CSIPSec& aSIPSec,
			   TUint32 aCSeqNumber,
			   TBool aIsPrivateAddress,
			   CUserAgentState* aAckSenderState);	

	/**
	 * Stop and delete the CTransaction object.
	 *
	 * @pre iTransaction != NULL
	 * @pre iDeleteThisTransaction == NULL
	 * @post iTransaction == NULL
	 */
	void StopTransaction();

	void StopTimerUaTimeout();
	
	void StopTimerSIPSec();

	void CancelAllTimers();

	/**
	 * Selects the branch value to be used for ACK.
	 *
	 * @param aObserver IN: Callback to upper layer.
	 * @return Branch value to use, or an empty descriptor if a new branch will
	 *	       be generated.
	 */
	RStringF SelectBranchToUse(MTransactionOwner& aObserver) const;
	
	RStringF UsedBranch(MTransactionOwner& aObserver) const;

private: // Data

	//Used to create another CTransmitter or clone CInviteUAC.
	MSipConnectionMgr& iConnectionMgr;

	//This timer is started when the first 2xx is received. When the timer
	//expires, UA stops. Owned.
	CTimerStopUA* iTimerWait2xxRetransmissions;

	//Used to handle responses asynchronously even if SIPSec processed it
	//synchronously. Owned.
	CTimerAsyncSIPSec* iSIPSecTimer;

	//Tells if the local address is in IPv4 private address space
	TBool iIsPrivateAddress;

	//Initial state of InviteUACs that send the additional ACKs ("sub UACs").
	//For "sub UAC", the iAckSenderState is NULL. Not owned.
	CUserAgentState* iAckSenderState;

	//For handling ACKs after the first ACK, CInviteUAC creates a "sub UAC" for
	//handling every subsequent ACK. A "sub UAC" resolves the remote address
	//for ACK and sends it to network. "sub UACs" are owned by the main
	//CInviteUAC who created them. "sub UACs" don't receive messages from
	//ConnectionMgr, as they are not stored in CTransactionStore.
	RPointerArray<CInviteUAC> iAckSenders;

	//Remembers the callback that was used when the first ACK to a 2xx was
	//sent. Used to check if a subsequent ACK is a retransmission. Not owned.
	//UAC still updates iObserver each time an ACK is sent, and uses it for
	//calling TransactionEnded.
	MTransactionOwner* iObserverForFirstAck;

	//Indicates is the INVITE client transaction has been canceled.
	//If this flag is ETrue and InviteUAC ends because of timeout, the reason
	//is converted to KErrCancel before passing it to upper layer.
	TBool iCanceled;

	//Used only to store a detached INVITE client transaction that couldn't be
	//given to DeleteMgr due to lack of memory. Owned.
	CTransactionBase* iDeleteThisTransaction;

private: // For testing purposes

#ifdef CPPUNIT_TEST
	friend class CInviteUAC_Start_Test;
	friend class CInviteUAC_ResolveAddress_Test;
	friend class CInviteUAC_WaitResponse_Test;
	friend class CInviteUAC_WaitAckFromApp_Test;
	friend class CInviteUAC_ResolveAckAddress_Test;
	friend class CInviteUAC_SendingAck_Test;
	friend class CUserAgentClient_Test;
	friend class CTransactionUser_Test;
#endif

	void __DbgTestInvariant() const;

	};

#endif // end of INVITEUAC_H

// End of File