// 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          : InviteClientTaStates.cpp
// Part of       : Transaction
// Version       : SIP/5.0
//



#include "siprequest.h"
#include "sipresponse.h"
#include "SipAssert.h"
#include "SIPMessageUtility.h"

#include "InviteClientTa.h"
#include "InviteClientTaStates.h"
#include "ClearProxy.h"


// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::CInviteClientTa_Calling
// -----------------------------------------------------------------------------
//
CInviteClientTa_Calling::CInviteClientTa_Calling()
	{
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::~CInviteClientTa_Calling
// -----------------------------------------------------------------------------
//
CInviteClientTa_Calling::~CInviteClientTa_Calling()
	{
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::GetState
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Calling::GetState(CSIPInternalStates::TState& aState) const
    {
    aState = CSIPInternalStates::ETransactionCalling;
    }

#if defined(USE_SIP_LOGS)
// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::Log
// -----------------------------------------------------------------------------
//
const TDesC8& CInviteClientTa_Calling::Log() const
	{
	_LIT8(KState, "Calling");
	return KState;
	}
#endif

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void
CInviteClientTa_Calling::SetNeighbourStates(CTransactionState& aProceeding,
                                 			CTransactionState& aCompleted)
	{
	iProceeding = &aProceeding;
	iCompleted = &aCompleted;
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::SendRequestL
// CleanupItem handles ownership of aOutboundProxy in case of leave.
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Calling::SendRequestL(CTransaction& aTransaction,
										   CSIPRequest& aInvite,
										   const TInetAddr& aAddress,										   
										   RStringF aProtocol,
										   TBool aForceUDP,
										   const TSIPTransportParams& aParams,
										   CUri8* aOutboundProxy) const
	{
    __SIP_ASSERT_LEAVE(CSIPMessageUtility::CheckTransport(aProtocol),
                       KErrArgument);

	CInviteClientTransaction& ta = CInviteClientTransaction::Ptr(aTransaction);

	TClearProxy clearProxy(ta);
    CleanupStack::PushL(clearProxy.CleanupItem());

	ta.StoreRequest(aInvite,
					aAddress,
					aParams,
					aProtocol,
					aForceUDP,
					aOutboundProxy);
	ta.SendToTransmitterL();	

	CleanupStack::Pop(); //cleanupItem
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::SendCompleteL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Calling::SendCompleteL(CTransaction& aTransaction) const
	{
	CInviteClientTransaction& ta = CInviteClientTransaction::Ptr(aTransaction);
	ta.CheckForTransportChange();
	ta.StartTimerBUnlessExistsL();

	if (aTransaction.IsUnreliableTransportUsed())
		{
		ta.StartTimerAL();
		}
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::SendFailedL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Calling::SendFailedL(CTransaction& aTransaction,
										  TInt aError) const
	{    
	aTransaction.TerminatedL(aError);
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::ReceiveL
// If 2xx is received, UAC terminates the transaction. Stop timers when
// transaction can't return to previous state (ReceiveResponseL has returned).
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Calling::ReceiveL(CTransaction& aTransaction,
	                                   CSIPResponse* aResponse) const
	{
    __SIP_ASSERT_LEAVE(aResponse, KErrArgument);

	CInviteClientTransaction& ta = CInviteClientTransaction::Ptr(aTransaction);

	if (ta.ShouldTaHandleResponse(aResponse))
		{
		CTransactionTimer* proceedingTimer = NULL;
		CTransactionTimer* natTimer = NULL;
		if (!CSIPMessageUtility::IsFinalResponse(*aResponse))
			{
			proceedingTimer = ta.StartTimerProceedingL();
			natTimer = ta.StartTimerNATL();
            aTransaction.ChangeState(*iProceeding);
			}

		ta.ReceiveResponseL(aResponse,
							*this,
							*iCompleted,
							proceedingTimer,
							natTimer);
        //Stop retransmission timer A. Timer B has only effect in Calling state
		ta.StopTimerA();
		ta.StopTimerB();
		}
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Calling::TimerExpiredL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Calling::TimerExpiredL(CTransaction& aTransaction,
										    TTimerId aTimerId,
										    TAny* aTimerParam) const
	{    
    __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument);

	HandleTimerExpirationL(aTransaction, aTimerId, aTimerParam);
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::CInviteClientTa_Proceeding
// -----------------------------------------------------------------------------
//
CInviteClientTa_Proceeding::CInviteClientTa_Proceeding()
	{
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::~CInviteClientTa_Proceeding
// -----------------------------------------------------------------------------
//
CInviteClientTa_Proceeding::~CInviteClientTa_Proceeding()
	{
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::GetState
// -----------------------------------------------------------------------------
//
void
CInviteClientTa_Proceeding::GetState(CSIPInternalStates::TState& aState) const
    {
    aState = CSIPInternalStates::ETransactionProceeding;
    }

#if defined(USE_SIP_LOGS)
// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::Log
// -----------------------------------------------------------------------------
//
const TDesC8& CInviteClientTa_Proceeding::Log() const
	{
	_LIT8(KState, "Proceeding");
	return KState;
	}
#endif

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::SetNeighbourStates
// -----------------------------------------------------------------------------
//
void
CInviteClientTa_Proceeding::SetNeighbourStates(CTransactionState& aCompleted)
	{
	iCompleted = &aCompleted;
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::SendCompleteL
// Occurs if 1xx comes before CTransmitter sent SendCompleteL or if iTimerNAT
// retransmitted INVITE.
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Proceeding::SendCompleteL(CTransaction& aTransaction) const
	{
	CInviteClientTransaction& ta = CInviteClientTransaction::Ptr(aTransaction);
	ta.CheckForTransportChange();
	ta.StartTimerNATL();
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::SendFailedL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Proceeding::SendFailedL(CTransaction& aTransaction,
											 TInt aError) const
	{
	aTransaction.TerminatedL(aError);
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::ReceiveL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Proceeding::ReceiveL(CTransaction& aTransaction,
	                                      CSIPResponse* aResponse) const
	{    
    __SIP_ASSERT_LEAVE(aResponse, KErrArgument);
	
	CInviteClientTransaction& ta = CInviteClientTransaction::Ptr(aTransaction);

	if (ta.ShouldTaHandleResponse(aResponse))
		{		
		TBool isErrorResponse = aResponse->IsErrorResponse();
		ta.ReceiveResponseL(aResponse, *this, *iCompleted);
		if (isErrorResponse)
            {
            ta.StopTimerProceeding();
            ta.StopTimerNAT();
            }
		}
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Proceeding::TimerExpiredL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Proceeding::TimerExpiredL(CTransaction& aTransaction,
											   TTimerId aTimerId,
											   TAny* aTimerParam) const
	{
    __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument);

	HandleTimerExpirationL(aTransaction, aTimerId, aTimerParam);
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::CInviteClientTa_Completed
// -----------------------------------------------------------------------------
//
CInviteClientTa_Completed::CInviteClientTa_Completed()
	{
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::~CInviteClientTa_Completed
// -----------------------------------------------------------------------------
//
CInviteClientTa_Completed::~CInviteClientTa_Completed()
	{
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::GetState
// -----------------------------------------------------------------------------
//
void
CInviteClientTa_Completed::GetState(CSIPInternalStates::TState& aState) const
    {
    aState = CSIPInternalStates::ETransactionCompleted;
    }

#if defined(USE_SIP_LOGS)
// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::Log
// -----------------------------------------------------------------------------
//
const TDesC8& CInviteClientTa_Completed::Log() const
	{
	_LIT8(KState, "Completed");
	return KState;
	}
#endif

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::SendCompleteL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Completed::SendCompleteL(CTransaction& aTransaction) const
	{
	CInviteClientTransaction::Ptr(aTransaction).StartTimerDUnlessExistsL();
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::SendFailedL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Completed::SendFailedL(CTransaction& aTransaction,
											TInt aError) const
	{
	aTransaction.TerminatedL(aError);
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::ReceiveL
// Retransmit ACK unless currently being sent.
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Completed::ReceiveL(CTransaction& aTransaction,
	                                     CSIPResponse* aResponse) const
	{
    __SIP_ASSERT_LEAVE(aResponse, KErrArgument);

	if (!aTransaction.IsTransmitterSending() && aResponse->IsErrorResponse())
        {
	    CInviteClientTransaction::Ptr(aTransaction).SendToTransmitterL();
        }

    delete aResponse;
	}

// -----------------------------------------------------------------------------
// CInviteClientTa_Completed::TimerExpiredL
// -----------------------------------------------------------------------------
//
void CInviteClientTa_Completed::TimerExpiredL(CTransaction& aTransaction,
											  TTimerId aTimerId,
											  TAny* aTimerParam) const
	{    
    __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument);	

	HandleTimerExpirationL(aTransaction, aTimerId, aTimerParam);
	}