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

//

// Local includes

#include "cnwsstranslookuptable.h"

#include "mnwsssessioneventhandler.h"

#include "mnwsstransactioneventhandler.h"

#include "mnwssoomhandler.h"

#include "tnwsswsptrhndpanic.h"

#include "testoom.h"

// Class signature

#include "cnwsswspcoeventdispatcher.h"

CNwssWspCOEventDispatcher* CNwssWspCOEventDispatcher::NewL(

											RWSPCOConn& aWspSession,

											MNwssSessionEventHandler& aSessEventHnd,

											MNwssTransactionEventHandler& aTransEventHnd,

										    MNwssOomHandler& aOutOfMemoryHnd

											)

	{

	return new(ELeave)CNwssWspCOEventDispatcher(aWspSession, aSessEventHnd,

												aTransEventHnd, aOutOfMemoryHnd);

	}

CNwssWspCOEventDispatcher::~CNwssWspCOEventDispatcher()

	{

	Cancel();

	}

CNwssWspCOEventDispatcher::CNwssWspCOEventDispatcher(

										RWSPCOConn& aWspSession,

		 								MNwssSessionEventHandler& aSessEventHnd,

										MNwssTransactionEventHandler& aTransEventHnd,

										MNwssOomHandler& aOutOfMemoryHnd

										)

	: CActive(CActive::EPriorityHigh),

	  iWspSession(aWspSession), iSessEventHnd(aSessEventHnd),

	  iTransEventHnd(aTransEventHnd), iOutOfMemoryHnd(aOutOfMemoryHnd)

	{

	CActiveScheduler::Add(this);

	}

void CNwssWspCOEventDispatcher::Start()

	{

	if (!IsActive())

		{

		iWspSession.GetEvent(iWspEvent, iTransaction, iStatus);

		SetActive();

		}

	}

void CNwssWspCOEventDispatcher::RunL()

	{

	RWSPCOConn::TEventType event = (RWSPCOConn::TEventType)iWspEvent();

	// Obtain the transaction ID for transaction events

	iTrId = KErrNotFound;

	if ( (event == RWSPCOConn::EMethodInvoke_cnf_t) ||

		 (event == RWSPCOConn::EMethodResult_ind_t) ||

		 (event == RWSPCOConn::EAbort_ind_t) )

		{

		__TESTOOMD(stkErr, iTransaction.Id(iTrId));

		User::LeaveIfError(stkErr);

		}

	// Testing only - simulate a WAP Stack OOM which would cause this AO to complete with KErrNoMemory

	TInt status = iStatus.Int();

#if defined (_DEBUG) && defined(__UNIT_TESTING__)

	TAny* _a = User::Alloc(sizeof(TInt));

	User::Free(_a);

	if (_a == NULL)

		status = KErrNoMemory;

#endif

	User::LeaveIfError(status);

	// Request the next event before processing this one.  It is important to do this here,

	// and not after the following event handling - since the handler may decide to cancel this

	// dispatcher as a result of the event, or even close iWspSession.

	Start();

	// Act according to the event type

	switch (event)

		{

		// dispatch session events to the session event handler

		case RWSPCOConn::EDisconnect_ind_s:

			{

			__DEBUGTESTLEAVE

			iSessEventHnd.HandleDisconnectIndL();

			} break;

		case RWSPCOConn::ESuspend_ind_s:

			{

			__DEBUGTESTLEAVE

			iSessEventHnd.HandleSuspendIndL();

			} break;

		case RWSPCOConn::EResume_cnf_s:

			{

			__DEBUGTESTLEAVE

			iSessEventHnd.HandleResumeCnfL();

			} break;

		case RWSPCOConn::EConnect_cnf_s:

			{

			__DEBUGTESTLEAVE

			iSessEventHnd.HandleConnectCnfL();

			} break;

		case RWSPCOConn::ERedirect_ind_s:

			{

			__DEBUGTESTLEAVE

			iSessEventHnd.HandleRedirectIndL();

			} break;

		// dispatch transaction events to the transaction event handler

		case RWSPCOConn::EMethodInvoke_cnf_t:

			{

			__DEBUGTESTLEAVE

			iTransEventHnd.HandleMethodInvokeCnfL(iTrId);

			} break;

		case RWSPCOConn::EMethodResult_ind_t:

			{

			__DEBUGTESTLEAVE

			iTransEventHnd.HandleMethodResultIndL(iTrId);

			} break;

		case RWSPCOConn::EAbort_ind_t:

			{

			__DEBUGTESTLEAVE

			iTransEventHnd.HandleAbortIndL(iTrId);

			} break;

		// push events are not supported, and should indeed never arise if the

		// capability negotiations with the WAP proxy have been successful

		case RWSPCOConn::EPush_ind_t:

		case RWSPCOConn::EConfirmedPush_ind_t:

			{

			TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::ECOPushNotSupported);

			} break;

		// exception event is treated like a session event

		case RWSPCOConn::EException_ind_e:

			{

			__DEBUGTESTLEAVE

			iSessEventHnd.HandleExceptionIndL();

			} break;

		default: 

			{

			TNwssWspTrHndPanic::Panic(TNwssWspTrHndPanic::EUnknownWspEvent);

			} break;

		};

	}

TInt CNwssWspCOEventDispatcher::RunError(TInt aError)

	{

	// Handle errors according to event type: if it's a transaction event, then send an AbortInd

	// for it. If it's a session event, then send DisconnectInd.

	RWSPCOConn::TEventType event = (RWSPCOConn::TEventType)iWspEvent();

	TInt err = KErrNone;

	// Act according to the event type

	switch (event)

		{

		case RWSPCOConn::ESuspend_ind_s:

		case RWSPCOConn::EResume_cnf_s:

		case RWSPCOConn::EConnect_cnf_s:

		case RWSPCOConn::ERedirect_ind_s:

		case RWSPCOConn::EDisconnect_ind_s:

			{

			if (aError != KErrNoMemory)

				TRAP(err, __DEBUGTESTLEAVE \

						  iSessEventHnd.HandleDisconnectIndL());

			if ((aError == KErrNoMemory) || (err == KErrNoMemory))

				{

				// We need to disconnect the WAP stack if there is any risk of

				// the client and WAP stack's session state becoming different

				TBool disconStack = ( (event != RWSPCOConn::EDisconnect_ind_s) &&

									  (event != RWSPCOConn::ERedirect_ind_s) );

				iOutOfMemoryHnd.SendOomDisconnect(disconStack);

				}

			} break;

		case RWSPCOConn::EMethodInvoke_cnf_t:

		case RWSPCOConn::EMethodResult_ind_t:

		case RWSPCOConn::EAbort_ind_t:

			{

			if (iTrId != KErrNotFound) // if we don't have a transaction ID we can't do anything

				{

				if (aError != KErrNoMemory)

					TRAP(err, __DEBUGTESTLEAVE \

							  iTransEventHnd.HandleAbortIndL(iTrId));

				if ((aError == KErrNoMemory) || (err == KErrNoMemory))

					iOutOfMemoryHnd.SendOomMethodAbort(iTrId, EFalse);

				}

			else

				{

				// We had an error whilst processing a transaction event, but we couldn't obtain

				// the transaction ID - so we'll have to disconnect the session instead.

				iOutOfMemoryHnd.SendOomDisconnect(ETrue);

				}

			} break;

		default:

			; // ignore - nothing else we can do

		};

	return KErrNone;

	}

void CNwssWspCOEventDispatcher::DoCancel()

	{

	iWspSession.CancelGetEvent();

	}