// 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          : NormalClientTa.cpp

// Part of       : Transaction

// Version       : SIP/5.0

//

#include "SipAssert.h"

#include "Lwtimer.h"

#include "sipresponse.h"

#include "NormalClientTa.h"

#include "TransactionState.h"

#include "TransactionTimer.h"

#include "TimerValues.h"

#include "RestoreTransactionState.h"

// -----------------------------------------------------------------------------

// CNormalClientTransaction::NewL

// -----------------------------------------------------------------------------

//

CNormalClientTransaction* CNormalClientTransaction::NewL(

										CUserAgentBase& aUserAgent,

										CTransmitter& aTransmitter,

										MTimerManager& aTimers,

										CTransactionState& aInitialState,

										TTimerValues& aTimerValues,

										MTransactionStore& aTransactionStore)

	{

	return new (ELeave) CNormalClientTransaction(aUserAgent,					

								                 aTransmitter,

								                 aTimers,

								                 aInitialState,

								                 aTimerValues,

								                 aTransactionStore);

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::CNormalClientTransaction

// -----------------------------------------------------------------------------

//

CNormalClientTransaction::CNormalClientTransaction(CUserAgentBase& aUserAgent,

										CTransmitter& aTransmitter,

										MTimerManager& aTimers,

										CTransactionState& aInitialState,

										TTimerValues& aTimerValues,

										MTransactionStore& aTransactionStore) :

	CClientTransaction(aUserAgent,

					   aTransmitter,

					   aTimers,

					   aInitialState,

					   aTimerValues,

					   aTransactionStore)

	{

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::~CNormalClientTransaction

// -----------------------------------------------------------------------------

//

CNormalClientTransaction::~CNormalClientTransaction()

	{

    //Scope operator to silence lint warning

    CNormalClientTransaction::CancelAllTimers();

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::IncreaseTimerEtoT2

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::IncreaseTimerEtoT2()

	{

	__TEST_INVARIANT;

	__ASSERT_DEBUG(!iTimerE,

		User::Panic(_L("CNormCTa:IncreaseTimerEtoT2"), KErrAlreadyExists));

	iTimerEDuration = iTimerValues.T2();

	__TEST_INVARIANT;	

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::StartTimerEL

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::StartTimerEL()

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(!iTimerE, KErrAlreadyExists);

	iTimerValues.DoubleUptoT2(iTimerEDuration);

	iTimerE = CTimerRetransmit::NewL(iTimers, this, iTimerEDuration);

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::StopTimerE

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::StopTimerE()

	{

	__TEST_INVARIANT;

	delete iTimerE;

	iTimerE = NULL;

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::StartTimerFUnlessExistsL

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::StartTimerFUnlessExistsL()

	{

	__TEST_INVARIANT;

	if (!iTimerF)

		{

		iTimerF = CTimerTerminateTa::NewL(iTimers,

										  this,

										  iTimerValues.Duration64xT1(),

										  KErrTimedOut);

		}

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::StopTimerF

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::StopTimerF()

	{

	__TEST_INVARIANT;

	delete iTimerF;

	iTimerF = NULL;

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::StartTimerKL

// Duration is 0s for reliable and T4 for unreliable transports.

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::StartTimerKL()

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(!iTimerK, KErrAlreadyExists);

	TUint32 duration = 0;	

	if (IsUnreliableTransportUsed())

		{

		duration = iTimerValues.T4();

		}

	iTimerK = CTimerTerminateTa::NewL(iTimers, this, duration);

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::StopTimerK

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::StopTimerK()

	{

	__TEST_INVARIANT;

	delete iTimerK;

	iTimerK = NULL;

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::DeleteTimer

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::DeleteTimer(const CTransactionTimer& aTimer)

	{

    __TEST_INVARIANT;

	if (&aTimer == iTimerE)

		{

		StopTimerE();

		}

	if (&aTimer == iTimerF)

		{

		StopTimerF();

		}

	if (&aTimer == iTimerK)

		{

		StopTimerK();		

		}

    __TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::CancelAllTimers

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::CancelAllTimers()

	{

	__TEST_INVARIANT;

	StopTimerE();

	StopTimerF();

	StopTimerK();

	__TEST_INVARIANT;

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::Ptr

// -----------------------------------------------------------------------------

//

CNormalClientTransaction&

CNormalClientTransaction::Ptr(CTransaction& aTransaction)

	{	

	return static_cast<CNormalClientTransaction&>(aTransaction);

	}

// -----------------------------------------------------------------------------

// CNormalClientTransaction::ReceiveResponseL

// Stop timers when transaction can no longer return to previous state.

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::ReceiveResponseL(CSIPResponse* aResponse,

                                    const CTransactionState& aCurrentState,

                                    const CTransactionState& aProceeding,

                                    const CTransactionState& aCompleted)

    {

    __TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aResponse, KErrArgument);

    if (ShouldTaHandleResponse(aResponse))

        {

		TUint respCode = aResponse->ResponseCode();

        if (respCode >= 200)

            {

            StartTimerKL();

            ChangeState(aCompleted);

			}

		else

			{

			ChangeState(aProceeding);

			}

        TRestoreTransactionState restoreState(*this, aCurrentState, iTimerK);

        CleanupStack::PushL(restoreState.CleanupItem());

		PassResponseToUserAgentL(aResponse);

        CleanupStack::Pop(); //cleanupItem

        if (respCode >= 200)

            {

            StopTimerE();

	        StopTimerF();

            }

		}

	__TEST_INVARIANT;

    }

// -----------------------------------------------------------------------------

// CNormalClientTransaction::__DbgTestInvariant

// -----------------------------------------------------------------------------

//

void CNormalClientTransaction::__DbgTestInvariant() const

	{

	if (iTimerEDuration > iTimerValues.T2())

		{

		User::Invariant();

		}

	}