/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

//  INCLUDES

#include "CIptvTestEventWaiter.h"

#include "MIptvTestEventWaiterObserver.h"

#include "CIptvTestEvent.h"

#include "VCXTestLog.h"

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

// CIptvTestEventWaiter::NewL

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

//

EXPORT_C CIptvTestEventWaiter* CIptvTestEventWaiter::NewL(MIptvTestEventWaiterObserver& aObserver)

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::NewL");

	CIptvTestEventWaiter* self = new (ELeave) CIptvTestEventWaiter(aObserver);

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	VCXLOGLO1("<<<CIptvTestEventWaiter::NewL");

	return self;

}

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

// CIptvTestEventWaiter::~CIptvTestEventWaiter

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

//

EXPORT_C CIptvTestEventWaiter::~CIptvTestEventWaiter()

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::~CIptvTestEventWaiter");

   	if( IsAdded() )

        {

        Deque(); // calls also Cancel()

        }

	iTimer.Close();

	Reset();

	VCXLOGLO1("<<<CIptvTestEventWaiter::~CIptvTestEventWaiter");

}

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

// CIptvTestEventWaiter::CheckTimeouts

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

//

EXPORT_C TInt CIptvTestEventWaiter::CheckTimeouts()

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::CheckTimeouts");

	TTime now;

	now.UniversalTime();

	TInt i;

	for(i=0; i<iEventQueue.Count();i++)

		{

		CIptvTestEvent* event = iEventQueue[i];

		if( event->HasTimeouted( now ) )

			{

			VCXLOGLO1("CIptvTestEventWaiter:: event timedout");

			iObserver.EventWaiterErrorL( KErrTimedOut, *event );

			VCXLOGLO1("<<<CIptvTestEventWaiter::CheckTimeouts");

			return KErrTimedOut;

			}

		}

	for(i=0; i<iEventDump.Count();i++)

		{

		CIptvTestEvent* event = iEventDump[i];

		if( event->HasTimeouted( now ) )

			{

			VCXLOGLO1("CIptvTestEventWaiter:: event timedout");

			iObserver.EventWaiterErrorL( KErrTimedOut, *event );

			VCXLOGLO1("<<<CIptvTestEventWaiter::CheckTimeouts");

			return KErrTimedOut;

			}

		}

	VCXLOGLO1("<<<CIptvTestEventWaiter::CheckTimeouts");

	return KErrNone;

}

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

// CIptvTestEventWaiter::AddEvent

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

//

EXPORT_C TInt CIptvTestEventWaiter::AddEvent(CIptvTestEvent* aEvent, TBool aSequential)

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::AddEvent");

	if(aSequential)

		{

		// First event in queue, activate it

		if(iEventQueue.Count() <= 0)

			{

			aEvent->Activate();

			}

		// Add event

		iEventQueue.Append( aEvent );

		}

	else

		{

		// All events in dump are active

		iEventDump.Append( aEvent );

		aEvent->Activate();

		}

	if( !IsActive() )

		{

		iTimer.After(iStatus, 1000000); // once in second

		SetActive();

		}

	VCXLOGLO1("<<<CIptvTestEventWaiter::AddEvent");

	return KErrNone;

}

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

// CIptvTestEventWaiter::EventHappened

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

//

EXPORT_C TInt CIptvTestEventWaiter::EventHappened(CIptvTestEvent* aEvent, CIptvTestEvent** aQueuedEvent)

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::EventHappened");

	TBool eventFound = EFalse;

	// Check first from the queue.

	VCXLOGLO1("Event queue:");

	for(TInt i=0; i<iEventQueue.Count();i++)

		{

		CIptvTestEvent* event = iEventQueue[i];

		TBuf<32> name;

		event->GetName(name);

		VCXLOGLO3(" queue %d: %S, %d", i, &name);

		}

	//CheckTimeouts();

	if(iEventQueue.Count() > 0)

		{

		CIptvTestEvent* event = iEventQueue[0];

		TBuf<32> name;

		event->GetName(name);

		VCXLOGLO2(" - %S", &name);

		if( !eventFound && event->Compare( *aEvent ) )

			{

			iEventQueue.Remove( 0 );

			if(iEventQueue.Count() > 0)

				{

				iEventQueue[0]->Activate();

				}

			iPastEvents.Append( event );

			eventFound = ETrue;

			*aQueuedEvent = event;

			VCXLOGLO1("*Match*");

			}

		}

	// Check if the event is in the dump, meaning it can happen any time.

	VCXLOGLO1("Event dump:");

	if(!eventFound)

		{

		for(TInt i=0; i<iEventDump.Count();i++)

			{

			CIptvTestEvent* event = iEventDump[i];

			TBuf<32> name;

			event->GetName(name);

			VCXLOGLO2(" - %S", &name);

			if( !eventFound && event->Compare( *aEvent ) )

				{

				iEventDump.Remove( i );

				iPastEvents.Append( event );

				eventFound = ETrue;

				*aQueuedEvent = event;

				VCXLOGLO1("*Match*");

				}

			}

		}

	// Event was found and there's no more events in queues. Message observer that all events are validated.

	if( eventFound && iEventQueue.Count() == 0 && iEventDump.Count() == 0 )

		{

		iObserver.EventWaiterAllEventsValidated();

		}

	if( !eventFound )

		{

		VCXLOGLO1("CIptvTestEventWaiter:: Event not found from queues.");

		if(iEventQueue.Count() > 0)

			{

			CIptvTestEvent* event = iEventQueue[0];

			*aQueuedEvent = event;

			}

		VCXLOGLO1("<<<CIptvTestEventWaiter::EventHappened");

		return KErrNotFound;

		}

	VCXLOGLO1("<<<CIptvTestEventWaiter::EventHappened");

	return KErrNone;

}

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

// CIptvTestEventWaiter::Reset

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

//

EXPORT_C TInt CIptvTestEventWaiter::Reset()

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::Reset");

	iEventQueue.ResetAndDestroy();

	iEventDump.ResetAndDestroy();

	iPastEvents.ResetAndDestroy();

	VCXLOGLO1("<<<CIptvTestEventWaiter::Reset");

	return KErrNone;

}

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

// CIptvTestEventWaiter::GetEventCount

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

//

EXPORT_C TInt CIptvTestEventWaiter::GetEventCount()

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::GetEventCount");

	TInt count = 0;

	count += iEventQueue.Count();

	count += iEventDump.Count();

	VCXLOGLO2("<<<CIptvTestEventWaiter:: events in queue: %d", count);

	VCXLOGLO1("<<<CIptvTestEventWaiter::GetEventCount");

	return count;

}

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

// CIptvTestEventWaiter::CIptvTestEventWaiter

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

//

CIptvTestEventWaiter::CIptvTestEventWaiter(MIptvTestEventWaiterObserver& aObserver)

 : CActive(CActive::EPriorityStandard), iObserver(aObserver)

{

}

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

// CIptvTestEventWaiter::ConstructL

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

//

void CIptvTestEventWaiter::ConstructL()

{

	VCXLOGLO1(">>>CIptvTestEventWaiter::ConstructL");

	User::LeaveIfError(iTimer.CreateLocal());

	CActiveScheduler::Add(this);

	VCXLOGLO1("<<<CIptvTestEventWaiter::ConstructL");

}

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

// CTestUtilConnectionWaiter::RunL()

//

// Handle request completion events

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

//

void CIptvTestEventWaiter::RunL()

	{

 	//VCXLOGLO1(">>>CIptvTestEventWaiter::RunL");

//    TInt statusCode = iStatus.Int();

	CheckTimeouts();

	// Start timer again if waiting for events

	if(iEventQueue.Count() > 0 || iEventDump.Count() > 0)

		{

		if( !IsActive() )

			{

			iTimer.After(iStatus, 1000000); // once in second

			SetActive();

			}

		}

    //VCXLOGLO1("<<<CIptvTestEventWaiter::RunL");

	}

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

// CIptvTestEventWaiter::DoCancel()

//

// Cancels ongoing requests

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

//

void CIptvTestEventWaiter::DoCancel()

	{

	VCXLOGLO1(">>>CIptvTestEventWaiter::DoCancel");

	iTimer.Cancel();

	VCXLOGLO1("<<<CIptvTestEventWaiter::DoCancel");

    }

// End of File