/*
* Copyright (c) 2007-2008 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:    The scheduler for the slideshow
 *
*/




#include "shweventrouter.h"
#include "shweventobserver.h"
#include "shweventpublisher.h"
#include "shwevent.h"
#include "shwslideshowenginepanic.h"

#include <glxlog.h>
#include <glxtracer.h>

// constants
namespace
	{
	// the typical amount of observers. In current design six, 
	// increase if there is more observers in future
	const TInt KEventObserverGranularity = 7;
	const TInt KMaxNumberOfConcurrentEvents = 10;
	}

// -----------------------------------------------------------------------------
// C++ Constructor. Save a few bits of rom with inlining
// -----------------------------------------------------------------------------
inline CShwEventRouter::CShwEventRouter()
	: iObservers( KEventObserverGranularity ), 
	iEvents( KMaxNumberOfConcurrentEvents )
	{
	// No implementation required
	}

// -----------------------------------------------------------------------------
// NewL. Static construction
// -----------------------------------------------------------------------------
CShwEventRouter* CShwEventRouter::NewL()
	{
	TRACER("CShwEventRouter::NewL()");
	CShwEventRouter* self = new( ELeave ) CShwEventRouter;
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
CShwEventRouter::~CShwEventRouter()
	{
	TRACER("CShwEventRouter::~CShwEventRouter");
	GLX_LOG_INFO("CShwEventRouter::~CShwEventRouter");
	// need to cleanup cloned events if we did get run down
	if( iEvents.Count() > 0 )
		{
		for( int i = 0; i < iEvents.Count(); i++ )
			{
			// call the destructor
			delete iEvents[ i ];
			}
		}
	// close the event array itself, this frees the memory
	iEvents.Close();
	// close the observer array itself, this frees the memory
	// NOTE! we did not have ownership of the observers
	iObservers.Close();
	}

// -----------------------------------------------------------------------------
// ConstructL.
// -----------------------------------------------------------------------------
void CShwEventRouter::ConstructL()
	{
	TRACER("CShwEventRouter::ConstructL");
	GLX_LOG_INFO("CShwEventRouter::ConstructL");
	// reserve space for the events so we should never leave in event handling
	iEvents.ReserveL( KMaxNumberOfConcurrentEvents );
	iInsideEventLoop = EFalse;
	}

// -----------------------------------------------------------------------------
// AddObserversL.
// -----------------------------------------------------------------------------
void CShwEventRouter::AddObserversL( TArray<MShwEventObserver*> aObservers )
	{
	TRACER("CShwEventRouter::AddObserversL");
    GLX_LOG_INFO( "CShwEventRouter::AddObserversL" );
	// add each observer
	for( TInt i = 0; i < aObservers.Count(); i++ )
		{
		AddObserverL( aObservers[ i ] );
		}
	}

// -----------------------------------------------------------------------------
// AddObserverL.
// -----------------------------------------------------------------------------
void CShwEventRouter::AddObserverL( MShwEventObserver* aObserver )
	{
	TRACER("CShwEventRouter::AddObserverL( MShwEventObserver* aObserver )");
    GLX_LOG_INFO("CShwEventRouter::AddObserverL(MShwEventObserver* aObserver)");
	__ASSERT_DEBUG( aObserver, User::Panic( _L("Null observer not allowed"), 1 ) );
	iObservers.AppendL( aObserver );
	}

// -----------------------------------------------------------------------------
// AddProducers.
// -----------------------------------------------------------------------------
void CShwEventRouter::AddProducers( TArray< MShwEventPublisher* > aPublishers )
	{
	TRACER("CShwEventRouter::AddProducers");
    GLX_LOG_INFO( "CShwEventRouter::AddProducers" );
	// add each publisher
	for( TInt i = 0; i < aPublishers.Count(); i++ )
		{
		AddProducer( aPublishers[ i ] );
		}
	}

// -----------------------------------------------------------------------------
// AddProducer.
// -----------------------------------------------------------------------------
void CShwEventRouter::AddProducer( MShwEventPublisher* aPublisher )
	{
	TRACER("CShwEventRouter::AddProducers(MShwEventPublisher* aPublisher)");
    GLX_LOG_INFO( "CShwEventRouter::AddProducer" );
	// give the publisher the event queue so they can start calling us
	aPublisher->SetEventQueue( this );
	}

// -----------------------------------------------------------------------------
// SendEventL. The method that handles the event dispatching.
// The events are dispatched in same order as they are sent, so if an event 
// is sent while previous is beeing dispatched we queue the event and 
// send it after the previous is dispatched to all observers
// -----------------------------------------------------------------------------
void CShwEventRouter::SendEventL( MShwEvent* aEvent )
	{
	TRACER("CShwEventRouter::SendEventL( MShwEvent* aEvent )");
    GLX_LOG_INFO( "CShwEventRouter::SendEvent" );
	__ASSERT_DEBUG( aEvent, User::Panic( _L("Null event not allowed"), 2 ) );

	// add the event to the queue
	// need to clone the event as the calling code may get out of scope
	// before we have time to deliver the event
	// this should never leave as we have reserved space in the array
	MShwEvent* clone = aEvent->CloneLC();
	iEvents.AppendL( clone );
	// we take ownership of the clone so pop it off the stack
	CleanupStack::Pop( clone );
	
	// are we inside event loop: when an event is beeing sent we may be 
	// delivering an earlier event
	if( iInsideEventLoop )
		{
		// there is an event beeing served so queue the event and return
		// the event will be served once previous one is served
		return;
		}
	// ok, dwell into the event serving loop
	// when we fall here we are just about to serve the one event
	// we may get new events while processing the old ones however
	iInsideEventLoop = ETrue;
	do
		{
		// take the first event
		MShwEvent* event = iEvents[ 0 ];
		TInt i = 0;
		// notify all observers
		for( ; i < iObservers.Count(); i++ )
			{
			iObservers[ i ]->NotifyL( event );
			}
		// this event is served, remove it and delete it
		iEvents.Remove( 0 );
		// delete the clone
		delete event;
		// if there are new events, deliver them as well
		}
	while( iEvents.Count() > 0 );
	// done processing events, safe to enter the loop again
	iInsideEventLoop = EFalse;
	}