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

// Part of       : Transaction

// Version       : SIP/5.0

//

#include "SipAssert.h"

#include "TransactionMgr.h"

#include "NormalClientTa.h"

#include "InviteClientTa.h"

#include "NormalServerTa.h"

#include "InviteServerTa.h"

#include "NormalClientTaStates.h"

#include "InviteClientTaStates.h"

#include "NormalServerTaStates.h"

#include "InviteServerTaStates.h"

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

// CTransactionMgr::NewL

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

//

CTransactionMgr* CTransactionMgr::NewL(MTimerManager& aTimers,								   

									   MTransactionStore& aTransactionStore)

	{

	CTransactionMgr* self = new (ELeave) CTransactionMgr(aTimers,														 

														 aTransactionStore);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CTransactionMgr::CTransactionMgr

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

//

CTransactionMgr::CTransactionMgr(MTimerManager& aTimers,

								 MTransactionStore& aTransactionStore) :

	iTimers(aTimers),

	iTransactionStore(aTransactionStore)

	{

	}

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

// CTransactionMgr::ConstructL

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

//

void CTransactionMgr::ConstructL()

	{

	//Invite client transaction states

	iInviteClientTa_Calling = new (ELeave) CInviteClientTa_Calling;

	iInviteClientTa_Proceeding = new (ELeave) CInviteClientTa_Proceeding;

	iInviteClientTa_Completed = new (ELeave) CInviteClientTa_Completed;

	iInviteClientTa_Calling->SetNeighbourStates(*iInviteClientTa_Proceeding,

												*iInviteClientTa_Completed);

	iInviteClientTa_Proceeding->SetNeighbourStates(*iInviteClientTa_Completed);

	//Non-Invite client transaction states

	iNormalClientTa_Trying = new (ELeave) CNormalClientTa_Trying;

	iNormalClientTa_Proceeding = new (ELeave) CNormalClientTa_Proceeding;

	iNormalClientTa_Completed = new (ELeave) CNormalClientTa_Completed;

	iNormalClientTa_Trying->SetNeighbourStates(*iNormalClientTa_Proceeding,

											   *iNormalClientTa_Completed);

	iNormalClientTa_Proceeding->SetNeighbourStates(*iNormalClientTa_Completed);

	//Invite server transaction states

	iInviteServerTa_Proceeding = new (ELeave) CInviteServerTa_Proceeding;

	iInviteServerTa_Completed = new (ELeave) CInviteServerTa_Completed;

	iInviteServerTa_Confirmed = new (ELeave) CInviteServerTa_Confirmed;

	iInviteServerTa_Sending2xx = new (ELeave) CInviteServerTa_Sending2xx;

	iInviteServerTa_Proceeding->SetNeighbourStates(*iInviteServerTa_Completed,

												   *iInviteServerTa_Sending2xx);

	iInviteServerTa_Completed->SetNeighbourStates(*iInviteServerTa_Confirmed);

	//Non-Invite server transaction states

	iNormalServerTa_Trying = new (ELeave) CNormalServerTa_Trying;

	iNormalServerTa_Proceeding = new (ELeave) CNormalServerTa_Proceeding;

	iNormalServerTa_Completed = new (ELeave) CNormalServerTa_Completed;

	iNormalServerTa_Trying->SetNeighbourStates(*iNormalServerTa_Proceeding,

											   *iNormalServerTa_Completed);

	iNormalServerTa_Proceeding->SetNeighbourStates(*iNormalServerTa_Completed);

	}

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

// CTransactionMgr::~CTransactionMgr

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

//

CTransactionMgr::~CTransactionMgr()

	{	

	delete iInviteClientTa_Calling;

	delete iInviteClientTa_Proceeding;

	delete iInviteClientTa_Completed;

	delete iNormalClientTa_Trying;

	delete iNormalClientTa_Proceeding;

	delete iNormalClientTa_Completed;	

	delete iInviteServerTa_Proceeding;

	delete iInviteServerTa_Completed;

	delete iInviteServerTa_Confirmed;	

	delete iInviteServerTa_Sending2xx;

	delete iNormalServerTa_Trying;

	delete iNormalServerTa_Proceeding;

	delete iNormalServerTa_Completed;

	}

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

// CTransactionMgr::CreateTransactionL

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

//

CTransactionBase*

CTransactionMgr::CreateTransactionL(CTransactionBase::TTransactionType aType,

									CUserAgentBase& aUserAgent,

									CTransmitter& aTransmitter,

									TTimerValues& aTimerValues,

									TBool aRetransmitInvite)

	{

	CTransactionBase* ta = NULL;

	switch (aType)

		{

		case CTransactionBase::KServerTransaction:

			{

			ta = CNormalServerTransaction::NewL(aUserAgent,

											    aTransmitter,

											    iTimers,

											    *iNormalServerTa_Trying,

											    aTimerValues);

			break;

			}

		case CTransactionBase::KServerInviteTransaction:

			{

			ta = CInviteServerTransaction::NewL(aUserAgent,

											    aTransmitter,

											    iTimers,

											    *iInviteServerTa_Proceeding,

											    aTimerValues);

			break;

			}

		case CTransactionBase::KClientTransaction:

			{

			ta = CNormalClientTransaction::NewL(aUserAgent,

											    aTransmitter,

											    iTimers,

											    *iNormalClientTa_Trying,

											    aTimerValues,

											    iTransactionStore);

			break;

			}

		case CTransactionBase::KClientInviteTransaction:

			{

			ta = CInviteClientTransaction::NewL(aUserAgent,

											    aTransmitter,

											    iTimers,

											    *iInviteClientTa_Calling,

											    aTimerValues,

											    iTransactionStore,

											    aRetransmitInvite);

			break;

			}

		default:

			User::Leave(KErrArgument);

		}

	return ta;

	}

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

// CTransactionMgr::IsPossibleToSendCancel

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

//

TBool CTransactionMgr::IsPossibleToSendCancel(

	const CTransactionBase& aTransaction) const

	{

	return (!aTransaction.HasTerminated() &&

		    (static_cast<const CTransaction&>(aTransaction).State() ==

                iInviteClientTa_Proceeding));

	}