/*

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

*    Implementation for the CDosEventRcvService class

*

*/

#include <e32base.h>

#include "doseventrcvservice.h"

#include "doseventmanagerbase.h"

#include "doswaitingevent.h"

#include "dosclientserver.h"

#include "dosserver.h"

//

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

// CDosEventRcvService Constructor

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

//  

CDosEventRcvService::CDosEventRcvService()

: iEventQueue(_FOFF(CDosWaitingEvent,iLink)) , iQueueIter(iEventQueue)

{

	iRegistered = EFalse;

	iReady = EFalse;

}

//

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

// CDosEventRcvService Destructor

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

//  

CDosEventRcvService::~CDosEventRcvService()

{

	if(iRegistered) iEventManager->UnRegisterListener(this,iEvent);

	if (!iEventQueue.IsEmpty())

	{

		CDosWaitingEvent* item;

	    iQueueIter.SetToFirst(); 

	    while ((item = iQueueIter++) != NULL)

		{

			delete item;

		}

		iEventQueue.Reset();

	}

}

//

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

// CDosEventRcvService::NewL

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

//  

CDosEventRcvService* CDosEventRcvService::NewL(CEventManagerBase* aEventManager)

{

	CDosEventRcvService* result=new (ELeave) CDosEventRcvService;

	CleanupStack::PushL(result);

	result->ConstructL(aEventManager);

	CleanupStack::Pop();

	return result;

}

//

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

// CDosEventRcvService::ConstructL

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

//  

void CDosEventRcvService::ConstructL(CEventManagerBase* aEventManager)

{

	iEventManager = aEventManager;

}

//

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

// CDosEventRcvService::InformListener

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

//  

void CDosEventRcvService::InformListener(CDosWaitingEvent* aEvent)

{

	TInt err = KErrNone;

	if(iReady)

	{

		iReady = EFalse;

		if(aEvent->HasParameter())

		{

			TRAP(err,iMessage.WriteL(1, aEvent->Parameter()));

		}

		iMessage.Complete(err);

	}

	else

	{

		if(iQueue == EQueue) //The event is queued if the event supports queueing

			aEvent->AddMeToQueue(iEventQueue);

		else if(iQueue == EOnlyLast)

		{

			//In the EOnlyLast case the queue only has one member.

			if(!iEventQueue.IsEmpty())

			{

				// If there is an event, we remove it 

				CDosWaitingEvent* event = iEventQueue.First();

				event->RemoveMeFromQueueD(iEventQueue);

			}

			aEvent->AddMeToQueue(iEventQueue); // We add the latest event.

		}

	}

}

//

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

// CDosEventRcvService::ExecuteMessageL

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

//  

TInt CDosEventRcvService::ExecuteMessageL(const RMessage2& aMessage)

{

	TInt err=KErrNone;

	switch (aMessage.Function())

	{

		case ERegisterEvent:

			iEvent = (TInt32)aMessage.Ptr0();

			iEventManager->RegisterListenerL(this,iEvent);

			iRegistered=ETrue;

			return err;

		case EUnRegisterEvent:

			err = iEventManager->UnRegisterListener(this,iEvent);

			if(!err)

			{

				iRegistered=EFalse;

				iReady=EFalse;

			}

			return err;

		case EWaitEvent:

			iMessage = aMessage;

			iReady = ETrue;

			iQueue = (TQueueType)aMessage.Int0();

			if(iQueue == EQueue || iQueue == EOnlyLast)

			{		

				// If we have a Queue we take the events from it.

				if(!iEventQueue.IsEmpty())

				{

					//There are events in the queue. We execute the first now.

					CDosWaitingEvent* event = iEventQueue.First();

					InformListener(event);

					event->RemoveMeFromQueueD(iEventQueue);

				}

			}

			return KErrNone;

		case ECancelWaitEvent:

			if ( iReady )

				{

				iReady = EFalse;

				iMessage.Complete(KErrCancel);

				}

			return KErrNone;

		default:

			PanicClient(aMessage,EPanicIllegalFunction);

			return KErrNone;

	}

}