// Copyright (c) 2005-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:

// CSIPTransitionEngine implementation file.

// 

//

/**

 @file

 @internalComponent

*/

#include "transitionengine.h"

#include "SipStateMachine.h"

#include <siphlerr.h>

CSIPTransitionEngine* CSIPTransitionEngine::NewL(CSIP& aSip, TInt aIapId)

/**

Transition Engine Instantiation Function

*/

	{	

	CSIPTransitionEngine * self = new (ELeave) CSIPTransitionEngine(aSip, aIapId);

	CleanupStack::PushL (self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;	

	}

void CSIPTransitionEngine::ConstructL()

/**

2nd Phase construction

*/

	{

	__FLOG_1(_L("CSIPTransitionEngine %08x:\tConstructL(), expect 'ConstructL successful', otherwise the method left"), this);

	ASSERT(iConnection == NULL);

	// Startup Nokia Stack Related Objects

	iConnState = CSIPConnection::EInactive;

	__FLOG_1(_L("CSIPTransitionEngine %08x:\tInstantiating CSIPProfileRegistry - may leave"), this);

	iProfileRegistry = CSIPProfileRegistry::NewL(iSIP, *this);

	CleanupStack::PushL(iProfileRegistry);

	__FLOG_1(_L("CSIPTransitionEngine %08x:\tInstantiating CSIPHttpDigest - may leave"), this);

	iDigest = CSIPHttpDigest::NewL(iSIP, *this );

	CleanupStack::PushL(iDigest);

	__FLOG_1(_L("CSIPTransitionEngine %08x:\tInstantiating CSIPConnection - may leave"), this);

    iConnection = CSIPConnection::NewL(iSIP, iIapId, *this );

	// Wait for the connectio to become Active 

	if( iConnection->State() == CSIPConnection::EInit )

		{

		iActiveWait.Start();

		}

	__FLOG_1(_L("CSIPTransitionEngine %08x:\tConstructL successful"), this);		

    CleanupStack::Pop(2);

	}

CSIPTransitionEngine::CSIPTransitionEngine(CSIP& aSip, TInt aIapId)

:iIapId(aIapId),

 iSIP(aSip)

/**

constructor

*/

	{

	// Open Logs

	__FLOG_OPEN(_L8("SipStateMachine"), _L8("TransitionEngine"));

	__FLOG_1(_L("[TransitionEngine]:[%x]::CSIPTransitionEngine() "), this);	

	}

CSIPTransitionEngine::~CSIPTransitionEngine()

/**

Destructor , cleanup wil be done here

*/

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine [%x]::~CSIPTransitionEngine"), this);

	// Delete all the State Machines that are there registered

	// with the TE

	CHLStateMachine *hlSm = NULL;

	TInt numElements = iSMArray.Count();

	for(TInt count=0; count<numElements; count++)

		{

		hlSm = (CHLStateMachine*)iSMArray[count];

		hlSm->iDialog = NULL;

		hlSm->iTransaction = NULL;

		delete hlSm;

		}

	iSMArray.Close();

	// Clean Profiles

	numElements = iProfileArray.Count();

	for (TInt count = 0; count<numElements; count++)

		{

		CSIPProfile* profile = iProfileArray[count];

		delete profile;

		}

	iProfileArray.Close();

	//Close RegClientArray

	//TransitionEngine will be deleted only when no SIPConnProviders are using this

	iRegClientArray.Close();

	delete iProfileRegistry;

	delete iConnection;

    __FLOG_1(_L("<<completed...>> CSIPTransitionEngine [%x]::~CSIPTransitionEngine"), this);

	__FLOG_CLOSE;	

	}

void CSIPTransitionEngine::ConnectionStateChanged( CSIPConnection::TState aState )

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine [%x]::ConnectionStateChanged()"), this);

	// No Matter what the connection state is become we have to stop the wait

	if (iActiveWait.IsStarted())

		{

			iActiveWait.AsyncStop();

		}

	if (iConnState == CSIPConnection::EActive && aState != CSIPConnection::EActive)

		{

		//CSIP Connection Lost

		//Notify all Registration Clients

		for ( TInt count = 0; count<iRegClientArray.Count(); count++)

			{

			iRegClientArray[count]->ErrorOccurred(KErrSIPTransportFailure);

			}

		}

	}

void CSIPTransitionEngine::IncomingRequest( CSIPServerTransaction* aTransaction )

/**

Incoming request recieved outside a dialog

*/	

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<Recieved Outside of a Dialog>>"),this);

	CleanupStack::PushL(aTransaction); //we're take over the ownership.

	RStringF method = aTransaction->RequestElements()->Method();

	if(method == SIPStrings::StringF(SipStrConsts::EInvite))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<Received Request Invite>>"),this);

		TSipMsgBundle	msgBundle;

		// Create a dialog Association and set server transaction

		CSIPInviteDialogAssoc*	dialogassoc = CSIPInviteDialogAssoc::NewL(*aTransaction);

		CleanupStack::PushL(dialogassoc);

		msgBundle.iRequest = TSipHLConsts::ERequestInvite;

		msgBundle.iDialog = dialogassoc;

		msgBundle.iServTransaction = aTransaction;

		// Look For the state machine which is responsible for handling 

	 	// this particular request

	 	CSipStateMachine*	smPtr = FindSMForIncomingCall();

	 	if(smPtr)

	 		{

	 		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<Found State Machine to Handle the Request>>"),this);

	 		smPtr->IncomingRequestOutsideDialog(msgBundle);	

	 		CleanupStack::Pop(dialogassoc);

	 		CleanupStack::Pop(aTransaction);

	 		}

	 	else

	 		{// return NotFound

	 		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<No State Machine found to Handle the Request>>"),this);

	 		__FLOG_0(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<sending 404>>"));

	 		CSIPResponseElements *ResElem = CSIPResponseElements::NewLC(

							404, SIPStrings::StringF(SipStrConsts::EPhraseNotFound));

			aTransaction->SendResponseL(ResElem);

			CleanupStack::Pop(ResElem);		

			CleanupStack::PopAndDestroy(aTransaction);

			CleanupStack::PopAndDestroy(dialogassoc);

	 		}

		}

	 else

	 	{ // bad request , not supported here

	 	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<Received Request other than Invite>>"),this);

	 	__FLOG_0(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<sending 404>>"));

	 	CSIPResponseElements *ResElem = CSIPResponseElements::NewLC(

							400, SIPStrings::StringF(SipStrConsts::EPhraseBadRequest));

		aTransaction->SendResponseL(ResElem);

		CleanupStack::Pop(ResElem);		

		CleanupStack::PopAndDestroy(aTransaction);

	 	}		

	}

void CSIPTransitionEngine::IncomingRequest( CSIPServerTransaction* aTransaction, CSIPDialog& aDialog )

/**

Incoming request recieved on an established dialog

*/

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<Recieved on Established Dialog>>"),this);

	//find state machine from associated DialogAssoc

	CSipStateMachine* smPtr = FindStateMachine(aDialog);

	//Extract Method

	RStringF method = aTransaction->RequestElements()->Method();

	TSipMsgBundle msgBundle;

	if (method == SIPStrings::StringF(SipStrConsts::EInvite))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<INVITE>>"),this);

		msgBundle.iRequest = TSipHLConsts::ERequestInvite;		

		}

	else if (method == SIPStrings::StringF(SipStrConsts::EAck))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<ACK>>"),this);

		msgBundle.iRequest = TSipHLConsts::ERequestAck;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::EBye))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<BYE>>"),this);

		msgBundle.iRequest = TSipHLConsts::ERequestBye;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::ECancel))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<CANCEL>>"),this);

		msgBundle.iRequest = TSipHLConsts::ERequestCancel;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::ENotify))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<NOTIFY>>"),this);

		msgBundle.iRequest = TSipHLConsts::ERequestNotify;

		}

	msgBundle.iServTransaction = aTransaction;

	// Match the state machine which is associated with this message

	if(smPtr)

		{

		__FLOG_0(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingRequest() <<Found state machine for handling this request>>"));

		smPtr->IncomingRequestInsideDialog(msgBundle);	

		}

	}

void CSIPTransitionEngine::IncomingResponse( CSIPClientTransaction& /*aTransaction*/ )

	{

	// We will Not handle this case

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<Not HANDLED CASE CALLED < ITS AN ERROR>>"),this);

	}

void CSIPTransitionEngine::IncomingResponse( CSIPClientTransaction& aTransaction,

							   CSIPDialogAssocBase& aDialogAssoc )

/**

Incoming Response inside an established dialog is received

*/

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<Recieved on Established Dialog>>"),this);

	CSIPCSeqHeader* CseqHdr = (CSIPCSeqHeader*)aTransaction.ResponseElements()->CSeqHeader();

	RStringF method = CseqHdr->Method();

	TSipMsgBundle msgBundle;

	msgBundle.iStatusCode = aTransaction.ResponseElements()->StatusCode();

	msgBundle.iClientTransaction = &aTransaction;

	if (method == SIPStrings::StringF(SipStrConsts::EInvite))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<INVITE>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseInvite;		

		}

	else if (method == SIPStrings::StringF(SipStrConsts::EAck))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<ACK>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseAck;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::EBye))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<BYE>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseBye;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::ECancel))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<CANCEL>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseCancel;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::ESubscribe))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<SUBSCRIBE>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseSubscribe;

		}

	//Find the StateMachine associated with this Dialog

	CSipStateMachine* smPtr = FindStateMachine(aDialogAssoc);

	if (smPtr)

	{

	//Set the error code in case the status code is 3XX 6XX errors.

		if(msgBundle.iStatusCode >299)

		{

		msgBundle.iErrCode= KErrSIPErrorResponse;

		smPtr->ErrorOccured(msgBundle);

		}

		else

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<Found state machine for handling this response>>"),this);

		smPtr->IncomingResponse(msgBundle);

		}

	}	

}	

void CSIPTransitionEngine::IncomingResponse( CSIPClientTransaction& aTransaction,

							   CSIPInviteDialogAssoc* aDialogAssoc )

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<Recieved on InviteDialog Assoc>>"),this);

	CSIPCSeqHeader * CseqHdr = (CSIPCSeqHeader*)aTransaction.ResponseElements()->CSeqHeader();

	RStringF method = CseqHdr->Method();

	TSipMsgBundle msgBundle;

	msgBundle.iStatusCode = aTransaction.ResponseElements()->StatusCode();

	if (method == SIPStrings::StringF(SipStrConsts::EInvite))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<INVITE>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseInvite;		

		}

	else if (method == SIPStrings::StringF(SipStrConsts::EAck))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<ACK>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseAck;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::EBye))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<BYE>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseBye;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::ECancel))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<CANCEL>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseCancel;

		}

	else if (method == SIPStrings::StringF(SipStrConsts::ESubscribe))

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<SUBSCRIBE>>"),this);

		msgBundle.iResponse = TSipHLConsts::EResponseSubscribe;

		}

	//Find the StateMachine associated with this Dialog

	CSipStateMachine* smPtr = FindStateMachine(reinterpret_cast<CSIPDialogAssocBase*>(aDialogAssoc));

	if (smPtr)

		{

		__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<Found state machine for handling this response>>"),this);

		smPtr->IncomingResponse(msgBundle);

		}

	}

void CSIPTransitionEngine::IncomingResponse( CSIPClientTransaction& aTransaction,

							   CSIPRegistrationBinding& aRegistration )

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<Recieved on Registration Assoc>>"),this);

	CSipStateMachine* smPtr = FindStateMachine(aTransaction);

	if (smPtr)

		{

		TSipMsgBundle	msgBundle;

		if (aRegistration.IsContextActive()) // Registeration Response

			{

			__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<REGISTER>>"),this);

			msgBundle.iResponse = TSipHLConsts::EResponseRegister;

			msgBundle.iStatusCode = aTransaction.ResponseElements()->StatusCode();

			smPtr->IncomingResponse(msgBundle);

			}

		else // Unregistration Response

			{

			__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::IncomingResponse() <<UNREGISTER>>"),this);

			msgBundle.iResponse = TSipHLConsts::EResponseUnRegister;

			msgBundle.iStatusCode = aTransaction.ResponseElements()->StatusCode();

			smPtr->IncomingResponse(msgBundle);

			}

		}

	}

void CSIPTransitionEngine::ErrorOccured( TInt aError,

						   CSIPTransactionBase& aTransaction )

/**

This function will ask the particular state machine to handle the 

error

*/						   

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::ErrorOccurred(TInt aError,CSIPTransactionBase& aTransaction)"),this);

	CSipStateMachine* smPtr = FindStateMachine(aTransaction);

	if(smPtr)

		{

		TSipMsgBundle 	errBundle;

		errBundle.iErrCode = aError;

		smPtr->ErrorOccured(errBundle);

		}

	}

void CSIPTransitionEngine::ErrorOccured( TInt aError,

						   CSIPClientTransaction& aTransaction,

						   CSIPRegistrationBinding& /*aRegistration*/ )

/**

Handle errors related to Failed Registration. The registration binding is destroyed by

the state machine, so need not to be destroyed here

*/						   

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::ErrorOccurred(TInt aError,CSIPTransactionBase& aTransaction, CSIPRegistrationBinding & aRegistration)"),this);

	CSipStateMachine* smPtr = FindStateMachine(aTransaction);

	if(smPtr)

		{

		__FLOG_0(_L("[TransitionEngine]: <<Found State Machine to Handle the Error>>"));

		TSipMsgBundle msgBundle;

		msgBundle.iErrCode = aError;

		msgBundle.iResponse = TSipHLConsts::EResponseRegister;

		const CSIPResponseElements * resElems = aTransaction.ResponseElements();

		if(resElems)

			{

			msgBundle.iStatusCode = resElems->StatusCode();		

			}

		else

			{

			msgBundle.iStatusCode = -1;			

			}

		msgBundle.iClientTransaction = &aTransaction;

		smPtr->ErrorOccured(msgBundle);

		}

	else

		{

		__FLOG_0(_L("[TransitionEngine]: <<Not Found State Machine to Handle the Error>>"));	

		}

	}

void CSIPTransitionEngine::ErrorOccured( TInt aError,

						   CSIPTransactionBase& /*aTransaction*/,

						   CSIPDialogAssocBase& aDialogAssoc)

/**

Handles the errors related to failed transaction. No need delete the transaction

or the dialogassoc , as state machine will delete those upon termination

*/						   

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::ErrorOccurred(TInt aError,CSIPTransactionBase& aTransaction, CSIPDialogAssocBase & aDialogAssoc)"),this);

	CSipStateMachine* smPtr = FindStateMachine(aDialogAssoc);

	if(smPtr)

		{

		__FLOG_0(_L("[TransitionEngine]: <<Found State Machine to Handle the Error>>"));

		TSipMsgBundle	errBundle;

		errBundle.iErrCode = aError;

		// we cant get status code from response

		errBundle.iStatusCode = -1;	

		smPtr->ErrorOccured(errBundle);

		}

	else

		{

		__FLOG_0(_L("[TransitionEngine]: <<Not Found State Machine to Handle the Error>>"));

		// No State Machine, Nothing to do , SM might have been terminated by some 

		// other request

		return;	

		}

	}

void CSIPTransitionEngine::ErrorOccured(TInt aError, CSIPRefresh & aSIPRefresh)

/**

Handles Errors related to refresh 

*/

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::ErrorOccurred(TInt aError,CSIPRefresh & aSIPRefresh)"),this);

	TSipMsgBundle	errBundle;

	// Get The state machine associated with this particular Refresh request 

	const CSIPClientTransaction * clientTnx = aSIPRefresh.SIPTransaction();

	if(clientTnx)

		{

		__FLOG_0(_L("[TransitionEngine]: <<Found State Machine to Handle the Error>>"));

		CSipStateMachine* smPtr = FindStateMachine(clientTnx);

		if(smPtr)

			{

			errBundle.iErrCode = aError;

			const CSIPResponseElements * resElems = clientTnx->ResponseElements();

			if(resElems)

				{

				errBundle.iStatusCode = resElems->StatusCode();

				}

			else

				{

				errBundle.iStatusCode = -1;	

				}

			smPtr->ErrorOccured(errBundle);

			}

		else

			{

			// NO SM , nothing to do	

			}

		}

	else

		{

		__FLOG_0(_L("[TransitionEngine]: <<Not Found State Machine to Handle the Error>>"));

		// No Client Transaction , Noting can be done	

		}

	}

void CSIPTransitionEngine::ErrorOccured( TInt aError,

						   CSIPRegistrationBinding& aRegistration)

/**

Handles the error occurred with the periodic refreshing of an registration

binding

*/						   

	{

	__FLOG_1(_L("[TransitionEngine]: CSIPTransitionEngine[%x]::ErrorOccurred(TInt aError,CSIPRegistrationBinding& aRegistration)"),this);

	TSipMsgBundle	errBundle;

	// Get The state machine to Handle this condition 

	CSIPRefresh * refresh = aRegistration.SIPRefresh();

	if(refresh)

		{

		const CSIPClientTransaction *clientTxn = refresh->SIPTransaction();

		if(clientTxn)

			{

			CSipStateMachine* smPtr = FindStateMachine(clientTxn);

			if(smPtr)

				{

				errBundle.iErrCode = aError;

				const CSIPResponseElements * resElems = clientTxn->ResponseElements();

				if(resElems)

					{

					errBundle.iStatusCode = resElems->StatusCode();

					}

				else

					{

					errBundle.iStatusCode = -1;	

					}

				smPtr->ErrorOccured(errBundle);

				}