// 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:

// CSipStateMachine implementation file.

// 

//

/**

 @file

 @internalComponent

*/

#include <e32cons.h>

#include <e32base.h>

#include "SipStateMachine.h"

#include "StateIdle.h"

#include "StateSessionInitiation.h"

#include "StateSessionEstablished.h"

#include "StateSessionTerminate.h"

EXPORT_C CSipStateMachine * CSipStateMachine::NewL(CSIPTransitionEngine * aTe, MSIPStateMachineClient* aClient, TBool aSMDirection)

/**

 SIP State Machine Instantiation function

*/

	{

	CSipStateMachine * SipSm = new(ELeave) CSipStateMachine(aTe, aClient, aSMDirection);

	CleanupStack::PushL (SipSm);

	SipSm->ConstructL();

	CleanupStack::Pop (SipSm);

	return SipSm;

	}

void CSipStateMachine::ConstructL()

/**

 This Function will startup the state machine with a default

 state

 */

    {

    // Tell the TE there's another StateMachine wishing to speak to it.

    // Remek: Where do you remove it??? Cos i couldn't find !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    iTe->AddStateMachineL(this);

    // Initialize booleans

    iClientStimulus = EFalse;

    iServerStimulus = EFalse;

    iServerErrorStimulus = EFalse;

    iCallTerminateCallback = ETrue;

    iDeleteMeNow = EFalse;

    isInviteSM = EFalse;

    isSubscribeSM = EFalse;

    iCallTerminateCode.iErrorCode = KErrNone;

    iCallTerminateCode.iSipCode = KErrNone;

    // Construct States

    iStateIdle = CStateIdle::NewL(this);

    iCommandCntx.iCommandState = iStateIdle;

    iCommandCntx.iClientTx = NULL;

    iCommandCntx.iCancelClientTx = NULL;

    iCommandCntx.iServerTx = NULL;

    iCommandCntx.iRegBinding = NULL;

    iCommandCntx.iDialogAssoc = NULL;

    iStateSessionInit = CStateSessionInitiation::NewL(this);

    iStateSessionEstablished = CStateSessionEstablished::NewL(this);

    iStateSessionTerminate = CStateSessionTerminate::NewL(this);

    iActiveState = iStateIdle;

    this->Start(&iStatus, NULL);

    // Maithra's fix : For stray signal

    MakeActive();

    }

CSipStateMachine::CSipStateMachine(CSIPTransitionEngine * aTe, MSIPStateMachineClient* aClient,TBool aSMDirection) 

:CActive(EPriorityStandard), 

 iTe(aTe),

 iClient(aClient),

 iIncomingStateMachine (aSMDirection)

/**

 constructor

*/

	{

	// Open Logs

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

	__FLOG_1(_L("[SipStateMachine]:[%x]::CSipStateMachine() "), this);

	if(this->IsAdded() == EFalse)

		{

		CActiveScheduler::Add(this);

		}		

	}

CSipStateMachine::~CSipStateMachine()

/**

 destructor

*/

	{

	//Clean-up the iCommand Context

	Cleanup();

	iSipMsgBundle.Close();

	// delete States

	delete iStateIdle;

	delete iStateSessionInit;

	delete iStateSessionEstablished;	

	delete iStateSessionTerminate;

	// Close Logging

	__FLOG_0(_L("[SipStateMachine]: CSipStateMachine::~CSipStateMachine()"));

	__FLOG_CLOSE;

	}

EXPORT_C void CSipStateMachine::DeleteWhenReady()

/**

This function will mark the state machine that the CallTerminated callback

should not be called, and state machine should delete itself gracefully when

completed the operation

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::DeleteWhenReady()"),this);

	iClient = NULL;

	iCallTerminateCallback = EFalse;

	iDeleteMeNow = ETrue;

	// send the signal to state machine 

	if(iActiveState == NULL)

		{

		MakeActive();

		MarkRequestComplete(KErrNone);

		}

	}

EXPORT_C TSipParams & CSipStateMachine::GetSipParams()

/**

Returns the SIP parameters

*/

 	{

 	return iSipParams;	

 	}

EXPORT_C TInt CSipStateMachine::AcceptCall()

/**

Accepts and incoming call

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::AcceptCall()"),this);

	// This will always be invite as of now. The implementation of the function needs

	// changes when more functionality would be added onto this SM machine to handle more

	// SIp works

	isInviteSM = ETrue;

	return SendSIPResponse(TSipHLConsts::EResponseInvite);

	}

EXPORT_C TInt CSipStateMachine::StartCall()

/**

Start an outgoing call

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::StartCall()"),this);

	if(iSipParams.iRequest == TSipHLConsts::ERequestInvite)

		{

		isInviteSM = ETrue;

		return SendSIPRequest(TSipHLConsts::ERequestInvite);			

		}

	else if(iSipParams.iRequest == TSipHLConsts::ERequestSubscribe)

		{

		isSubscribeSM = ETrue;

		return SendSIPRequest(TSipHLConsts::ERequestSubscribe);			

		}

	else

		{

		iActiveState = NULL;

		return KErrNotSupported;			

		}

	}

EXPORT_C TInt CSipStateMachine::StopCall()

/**

Terminate an established connection

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::StopCall()"),this);

	if(isSubscribeSM)

		{

		return SendSIPRequest(TSipHLConsts::ERequestUnSubscribe);

		}

	else if(isInviteSM)

		{

		return SendSIPRequest(TSipHLConsts::ERequestBye);	

		}

	else

		{

		return KErrNotSupported;	

		}

	}

EXPORT_C TInt CSipStateMachine::RejectCall()

/**

Rejects an incoming call

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::RejectCall()"),this);

	return SendSIPResponse(TSipHLConsts::EResponseInviteReject);	

	}

TInt CSipStateMachine::SendSIPRequest(TSipHLConsts::SIP_REQUESTS aRequest)

/**

Sends a SIP request of a particular type 

*/

	{

	if(iActiveState == NULL)

		return KErrNotReady;

	iActiveState->ResetRequestResponse();

	iActiveState->SetClientRequest(aRequest);

	iClientStimulus = ETrue;

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);   

    	}

	MakeActive();

	MarkRequestComplete(KErrNone);

	return KErrNone;

	}

TInt CSipStateMachine::SendSIPResponse(TSipHLConsts::SIP_RESPONSES aResponse)

/**

Sends a SIP response of a particular type

*/

	{

	if(iActiveState == NULL)

    	{

    	return KErrNotReady;    

    	}

	iActiveState->ResetRequestResponse();

	iActiveState->SetClientResponse(aResponse);

	iClientStimulus = ETrue;

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);  

    	}

	MakeActive();

	MarkRequestComplete(KErrNone);

	return KErrNone;

	}

void CSipStateMachine::Start( TRequestStatus* aClientStatus, CSipStateBase* aErrorState )

/** 

Starts the state machine

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::Start()"),this);

	iClientStatus 	= 	aClientStatus;

	iErrorState 	= 	aErrorState;

	iSuspendRequest = 	EFalse;

	if (iClientStatus != NULL)

    	{

    	*iClientStatus = KRequestPending;    

    	}

	// we will not call RunL explicitly over here, That means the SM will be 

	// created in suspended mode.	  

	}

void CSipStateMachine::IncomingResponse(TSipMsgBundle aMsgBundle)

/**

Handles the incoming response inside a dialog

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::IncomingResponse()"),this);

	iActiveState->ResetRequestResponse();

	iActiveState->SetServerResponse(aMsgBundle.iResponse);

	// wake up the State Machine if suspended and pass the response back to the state

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);   

    	}

	iServerStimulus = ETrue;

	iSipMsgBundle.Append(aMsgBundle);

	MakeActive();

	MarkRequestComplete(KErrNone);	

	}

void CSipStateMachine::IncomingRequestInsideDialog(TSipMsgBundle aMsgBundle)

/**

Incoming Request inside established dialog

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::IncomingResponseInsideDialog()"),this);

	iActiveState->ResetRequestResponse();

	iActiveState->SetServerRequest(aMsgBundle.iRequest);

	// Delete the earlier server transaction if any as earlier transaction comes on outside a

	// dialog and not needed as new server transaction that comes with ACK / or inside dialoog

	// will be used

	if(iCommandCntx.iServerTx != NULL)

		{

		delete iCommandCntx.iServerTx;

		iCommandCntx.iServerTx = NULL;

		}

	// Set the server Transaction

	iCommandCntx.iServerTx = aMsgBundle.iServTransaction;

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);   

    	}

	iServerStimulus = ETrue;

	iSipMsgBundle.Append(aMsgBundle);

	MakeActive();

	MarkRequestComplete(KErrNone);

	}

void CSipStateMachine::ErrorOccured(TSipMsgBundle aErrBundle)	

/**

Handle the error from TE

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::ErrorOccurred()"),this);

	iActiveState->ResetRequestResponse();

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);   

    	}

	iServerErrorStimulus = ETrue;

	iSipMsgBundle.Append(aErrBundle);

	MakeActive();

	MarkRequestComplete(KErrNone);

	}

void CSipStateMachine::InviteCompleted(CSIPClientTransaction& /*aTransaction*/)

/**

This callback is called to maek the completion of invite 

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::InviteCompleted()"),this);

	// we will not match and delete the client transaction as it will be anyway

	// deleted when a BYE is being sent or received.

	}

void CSipStateMachine::IncomingRequest(TSipMsgBundle aMsgBundle)

/**

New Incoming request Inside established dialog

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::IncomingRequest()"),this);

	iActiveState->ResetRequestResponse();

	iActiveState->SetServerRequest(aMsgBundle.iRequest);

	iSipMsgBundle.Append(aMsgBundle);

	iServerStimulus = ETrue;

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);    

    	}

	MakeActive();

	MarkRequestComplete(KErrNone);

	}

void CSipStateMachine::IncomingRequestOutsideDialog(TSipMsgBundle & aMsgBundle)

/**

New Incoming request outside any established dialog

*/

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::IncomingRequestOutsideDialog()"),this);

	// set the command context

	iCommandCntx.iDialogAssoc	= (CSIPInviteDialogAssoc*)aMsgBundle.iDialog;

	iCommandCntx.iServerTx  	= aMsgBundle.iServTransaction;

	iActiveState->ResetRequestResponse();

	iActiveState->SetServerRequest(aMsgBundle.iRequest);

	iSipMsgBundle.Append(aMsgBundle);

	iServerStimulus = ETrue;

	if (iSuspendRequest)

    	{

    	SetSuspendRequest(EFalse);    

    	}

	MakeActive();

	MarkRequestComplete(KErrNone);

	}

void CSipStateMachine::GenerateInviteResponseL(

						CSIPServerTransaction *& aTransaction,

						TSipHLConsts::SIP_RESPONSE_TYPE aType)

/**

 */

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateInviteResponseL()"),this);

	switch(aType)

		{

		case TSipHLConsts::EResponseRinging:

			{

			__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateInviteResponseL() <<180 Ringing>>"),this);

			CSIPResponseElements *ResElem = CSIPResponseElements::NewLC(

							180, SIPStrings::StringF(SipStrConsts::EPhraseRinging));

			aTransaction->SendResponseL(ResElem);

			CleanupStack::Pop(ResElem);	

			}

			break;

		case TSipHLConsts::EResponse200OK:

			{

			__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateInviteResponseL() <<200 OK>>"),this);

			CSIPResponseElements *ResElem = CSIPResponseElements::NewLC(

							200, SIPStrings::StringF(SipStrConsts::EPhraseOk));

			aTransaction->SendResponseL(ResElem);

			CleanupStack::Pop(ResElem);		

			}

			break;

		case TSipHLConsts::EResponseReject:

			{

			__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateInviteResponseL() <<488 Reject>>"),this);

			CSIPResponseElements *ResElem = CSIPResponseElements::NewLC(

							488, SIPStrings::StringF(SipStrConsts::EPhraseNotAcceptableHere));

			aTransaction->SendResponseL(ResElem);

			CleanupStack::Pop(ResElem);			

			}

			break;

		default:

			{

			__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateInviteResponseL() <<No Response Generated>>"),this);

			}

		}

	}

void CSipStateMachine::GenerateSubscribeResponseL

						(CSIPServerTransaction *& aTransaction,

						TSipHLConsts::SIP_RESPONSE_TYPE aType)

/**

 */

	{

	__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateSubscribeResponseL()"),this);

	switch(aType)

		{

		case TSipHLConsts::EResponse200OK:

			{

			__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateSubscribeResponseL() <<200 OK>>"),this);

			CSIPResponseElements *ResElem = CSIPResponseElements::NewLC(

						200, SIPStrings::StringF(SipStrConsts::EPhraseOk));

			aTransaction->SendResponseL(ResElem);

			CleanupStack::Pop(ResElem);		

			// We will not delete this here , this will be deleted after giving notification

			// to the client

			/*

			delete aTransaction;

			aTransaction = NULL;

			*/

			}

			break;

		default:

			{

			__FLOG_1(_L("[SipStateMachine]: CSipStateMachine[%x]::GenerateSubscribeResponseL() <<No Response Generated>>"),this);

			}

		}

	}

HBufC8 * CSipStateMachine::GenerateNotificationData()

/**

*/

	{

	// Generate the notification parameter from the incoming server Transaction	

	CSIPServerTransaction *sTran = iCommandCntx.iServerTx;

	// get the request elements

	const CSIPRequestElements *reqElems = sTran->RequestElements();

	// Get the contents of the request elements

	// Get the Message Elements

	const CSIPMessageElements & msgElems = reqElems->MessageElements();

	// Get the content

	TPtrC8 content = msgElems.Content();

	HBufC8 * notificationData = NULL;

	TRAPD(err,notificationData = content.AllocL());

	if(err != KErrNone)

		{

		return NULL;

		}

	return notificationData;

	}

void CSipStateMachine::RunL()

/** 

 * Called on completion of one active event

 */

	{

	if (iStatus.Int() != KErrNone)

		{

		OnError();

		}

	if (iActiveState)

		{

		if (iSuspendRequest)

			{

			// do nothing wait for somebody to enable the state machine

			return;	

			}

		else if (iClientStimulus)

			{

			iClientStimulus = EFalse;

			MakeActive();

			iActiveState = iActiveState->ProcessClientL(iStatus);

			}

		else if (iServerStimulus)

			{

			iServerStimulus = EFalse;

			MakeActive();

			iActiveState = iActiveState->ProcessServerL(iStatus);

			}

		else if(iServerErrorStimulus)

			{

			iServerErrorStimulus = EFalse;

			MakeActive();