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

// Part of       : Transaction

// Version       : SIP/5.0

//

#include "SipAssert.h"

#include "Lwtimer.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "UserAgentBase.h"

#include "TimerValues.h"

#include "NormalServerTa.h"

#include "TransactionTimer.h"

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

// CNormalServerTransaction::NewL

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

//

CNormalServerTransaction*

CNormalServerTransaction::NewL(CUserAgentBase& aUserAgent,

							   CTransmitter& aTransmitter,

							   MTimerManager& aTimers,

							   CTransactionState& aInitialState,

							   TTimerValues& aTimerValues)

	{

	CNormalServerTransaction* self =

        new (ELeave) CNormalServerTransaction(aUserAgent,

											  aTransmitter,

											  aTimers,

											  aInitialState,

											  aTimerValues);

	CleanupStack::PushL(self);

	self->ConstructServerTaL();

	CleanupStack::Pop(self);

	return self;	

	}

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

// CNormalServerTransaction::CNormalServerTransaction

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

//

CNormalServerTransaction::CNormalServerTransaction(CUserAgentBase& aUserAgent,

										CTransmitter& aTransmitter,

										MTimerManager& aTimers,

										CTransactionState& aInitialState,

										TTimerValues& aTimerValues) :

	CServerTransaction(aUserAgent,

					   aTransmitter,

					   aTimers,

					   aInitialState,

					   aTimerValues)

	{

	}

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

// CNormalServerTransaction::~CNormalServerTransaction

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

//

CNormalServerTransaction::~CNormalServerTransaction()

	{

    //Scope operator to silence lint warning

    CNormalServerTransaction::CancelAllTimers();

	}

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

// CNormalServerTransaction::DeleteTimer

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

//

void CNormalServerTransaction::DeleteTimer(const CTransactionTimer& aTimer)

	{

	__TEST_INVARIANT;

	if (&aTimer == iTimerF2)

		{

		StopTimerF2();		

		}

	if (&aTimer == iTimerJ)

		{

		StopTimerJ();		

		}

	if (&aTimer == iTimerSend100)

		{

		StopTimerSend100();

		}

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::StartTimerF2UnlessExistsL

// Same duration as for timer F (64*T1).

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

//

void CNormalServerTransaction::StartTimerF2UnlessExistsL()

	{

	__TEST_INVARIANT;

	if (!iTimerF2)

		{

		iTimerF2 = CTimerTerminateTa::NewL(iTimers,

										   this,

										   iTimerValues.Duration64xT1(),

										   KErrTimedOut);

		}

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::StopTimerF2

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

//

void CNormalServerTransaction::StopTimerF2()

	{

	__TEST_INVARIANT;

	delete iTimerF2;

	iTimerF2 = NULL;

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::StartTimerJUnlessExistsL

// Duration is 0s for reliable and 64*T1 for unreliable transports.

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

//

void CNormalServerTransaction::StartTimerJUnlessExistsL()

	{

	__TEST_INVARIANT;

	if (!iTimerJ)

		{

		TUint32 duration = 0;

		if (IsUnreliableTransportUsed())

			{

			duration = iTimerValues.Duration64xT1();

			}

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

		}

	__TEST_INVARIANT;	

	}

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

// CNormalServerTransaction::StopTimerJ

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

//

void CNormalServerTransaction::StopTimerJ()

	{

	__TEST_INVARIANT;

	delete iTimerJ;

	iTimerJ = NULL;

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::IsTimerSend100Running

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

//

TBool CNormalServerTransaction::IsTimerSend100Running() const

	{

	__TEST_INVARIANT;

	return iTimerSend100 != NULL;

	}

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

// CNormalServerTransaction::StartTimerSend100L

// Same duration can be used for both reliable and unreliable transports.

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

//

void CNormalServerTransaction::StartTimerSend100L(CSIPRequest& aRequest)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(!iTimerSend100, KErrAlreadyExists);

	TUint32 duration = 0;

	TUint step = 0;

	iTimerValues.DoubleUptoT2(step);

	while (step < iTimerValues.T2())

		{

		duration += step;

		iTimerValues.DoubleUptoT2(step);

		}

	Create100L(aRequest);

	iTimerSend100 = CTimerSend100::NewL(iTimers,

									    this,

									    duration,

									    static_cast<CSIPResponse*>(iOutgoingMsg),

									    iTransportProtocol,

									    iTransportParams);

	//Timer took ownership of the SIP response

	iOutgoingMsg = NULL;

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::StopTimerSend100

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

//

void CNormalServerTransaction::StopTimerSend100()

	{

	__TEST_INVARIANT;

	delete iTimerSend100;

	iTimerSend100 = NULL;

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::ReceiveRetransmissionL

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

//

void CNormalServerTransaction::ReceiveRetransmissionL(CSIPRequest* aRequest)

	{

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	if (!IsTransmitterSending())

		{

		SendToTransmitterL();

		}

    delete aRequest;

	}

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

// CNormalServerTransaction::CancelAllTimers

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

//

void CNormalServerTransaction::CancelAllTimers()

	{

	__TEST_INVARIANT;

	StopTimerJ();

	StopTimerF2();

	StopTimerSend100();

	__TEST_INVARIANT;

	}

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

// CNormalServerTransaction::Ptr

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

//

CNormalServerTransaction&

CNormalServerTransaction::Ptr(CTransaction& aTransaction)

	{

	return static_cast<CNormalServerTransaction&>(aTransaction);

	}

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

// CNormalServerTransaction::__DbgTestInvariant

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

//

void CNormalServerTransaction::__DbgTestInvariant() const

	{

	//Timers J and F2 must not run at the same time

	if (iTimerJ && iTimerF2)

		{	

		User::Invariant();

		}

	}