/*
* 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 implementation of the engine API
 *
*/




// CLASS HEADER
#include "shwslideshowengineimpl.h"

// EXTERNAL INCLUDES
#include <alf/alfimagevisual.h>
#include <glxvisuallistmanager.h>
#include <mglxvisuallist.h>
#include <glxlog.h>
#include <glxtracer.h>

// INTERNAL INCLUDES
#include "shwengineobserver.h"
#include "shwplaybackfactory.h"
#include "shweventrouter.h"
#include "shwevent.h"
#include "shwslideshowenginepanic.h"
#include "shwhuiutility.h"

// -----------------------------------------------------------------------------
// C++ Constructor. Save a few bits of rom with inlining
// -----------------------------------------------------------------------------
inline CShwSlideshowEngineImpl::CShwSlideshowEngineImpl( 
    MShwEngineObserver& aObserver )
    : iObserver( aObserver )
	{
	// No implementation required
	}

// -----------------------------------------------------------------------------
// NewL. Static construction
// -----------------------------------------------------------------------------
CShwSlideshowEngineImpl* CShwSlideshowEngineImpl::NewL(
	MShwEngineObserver& aObserver )
	{
	TRACER("CShwSlideshowEngineImpl::NewL");
	GLX_LOG_INFO("CShwSlideshowEngineImpl::NewL");
	CShwSlideshowEngineImpl* self = 
	    new( ELeave ) CShwSlideshowEngineImpl( aObserver );
	CleanupStack::PushL( self );
	// perform 2nd phase
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// Destructor.
// -----------------------------------------------------------------------------
CShwSlideshowEngineImpl::~CShwSlideshowEngineImpl()
	{
	TRACER("CShwSlideshowEngineImpl::~CShwSlideshowEngineImpl");
	GLX_LOG_INFO("CShwSlideshowEngineImpl::~CShwSlideshowEngineImpl");
	// delete event router, it should not own any external objects
	delete iEventRouter;
	// delete the playback factory, it deletes the objects it owns
	// and they may require media or visual list
	delete iFactory;
	// clean the visual list (it has reference to media list)
	// Check that we got a manager
	if( iVisualListManager )
		{
		// Check if we got a list
		if( iVisualList )
			{
			// remove the list
			iVisualListManager->ReleaseList( iVisualList );
			}
		iVisualListManager->Close();
		}
	}

// -----------------------------------------------------------------------------
// ConstructL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::ConstructL()
	{
	TRACER("CShwSlideshowEngineImpl::ConstructL");
	GLX_LOG_INFO("CShwSlideshowEngineImpl::ConstructL");
	// get the visual list manager
	iVisualListManager = CGlxVisualListManager::ManagerL();
	}

// -----------------------------------------------------------------------------
// StartL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::StartL(
	CAlfEnv& aEnv, CAlfDisplay& aDisplay, MGlxMediaList& aItemsToShow,
	MShwMusicObserver& aMusicObserver, TSize aScreenSize )
	{
	TRACER("CShwSlideshowEngineImpl::StartL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::Start(Init)L" );

	// check that we've not already been started
	__ASSERT_ALWAYS( !iState, 
		NShwEngine::Panic( NShwEngine::EEngineStartLCalledInWrongState ) );

	// remember the display
	iDisplay = &aDisplay;

	// the media list is already ordered correctly for use
	iMediaList = &aItemsToShow;

	// construct the visual list
	iVisualList = iVisualListManager->AllocListL( 
		*iMediaList, aEnv, aDisplay, CAlfImageVisual::EScaleFitInside );

	// set the default icons to the list
	iVisualList->SetDefaultIconBehaviourL( ETrue );

	// construct the factory
	iFactory = CShwPlaybackFactory::NewL(
		&aEnv, 
		iVisualList, 
		iMediaList, 
		aMusicObserver,
		aScreenSize );

	// construct the event router
	iEventRouter = CShwEventRouter::NewL();
	// get the observers from factory
	// add them to router
	iEventRouter->AddObserversL( iFactory->EventObservers().Array() );
	// add ourself as observer
	iEventRouter->AddObserverL( this );

	// get the producers from factory
	// set the event producers to the router
	iEventRouter->AddProducers( iFactory->EventPublishers().Array() );
	// add ourself as publisher
	iEventRouter->AddProducer( this );

    // now all producers are there but they may need to do some
    // initialisation, send initialize event to allow that
	TShwEventInitialize initEvent;
	SendEventL( &initEvent );

	// set state now. We will get the event call (Notify)
	// once the first thumbnail is loaded and then we really start
	iState = CShwSlideshowEngine::EShwStateInitialized;

	GLX_LOG_INFO( "CShwSlideshowEngineImpl::Start(Init)L - End" );
	}

// -----------------------------------------------------------------------------
// NextItemL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::NextItemL()
	{
	TRACER("CShwSlideshowEngineImpl::NextItemL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::NextItemL" );

	if( CShwSlideshowEngine::EShwStateRunning == iState ||
		CShwSlideshowEngine::EShwStatePaused == iState )
		{
		// only change images if paused or playing
		TShwEventNextImage nextItemEvent;
		SendEventL( &nextItemEvent );
		}
	}

// -----------------------------------------------------------------------------
// PreviousItemL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::PreviousItemL()
	{
	TRACER("CShwSlideshowEngineImpl::PreviousItemL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::PreviousItemL" );
	
	if( CShwSlideshowEngine::EShwStateRunning == iState ||
		CShwSlideshowEngine::EShwStatePaused == iState )
		{
		// only change images if paused or playing
		TShwEventPreviousImage previousItemEvent;
		SendEventL( &previousItemEvent );
		}
	}

// -----------------------------------------------------------------------------
// PauseL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::PauseL()
	{
	TRACER("CShwSlideshowEngineImpl::PauseL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::PauseL" );
	// check state, if not running, don't bother pausing
	if( CShwSlideshowEngine::EShwStateRunning == iState )
		{
		// send the pause event to the router
		TShwEventPause pauseEvent;
		SendEventL( &pauseEvent );
				
		// update the state
		iState = CShwSlideshowEngine::EShwStatePaused;
		    
		// tell the observer that we paused the show
		iObserver.EnginePausedL();
		}
	}
// -----------------------------------------------------------------------------
// LSKPressedL
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::LSKPressedL()
    {
    TRACER("CShwSlideshowEngineImpl::LSKPressedL");
    GLX_LOG_INFO( "CShwSlideshowEngineImpl::LSKPressedL" );
    iObserver.EngineLSKPressedL();
        
    }
// -----------------------------------------------------------------------------
// ToggleControlsVisibiltyL., LSKPressedL
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::ToggleUiControlsVisibiltyL()
    {
    TRACER("CShwSlideshowEngineImpl::ToggleUiControlsVisibiltyL");
    GLX_LOG_INFO( "CShwSlideshowEngineImpl::ToggleUiControlsVisibiltyL" );
    
        // send the toggleUi event to the router
        TShwEventToggleControlUi toggleUi;
        SendEventL( &toggleUi );
        // tell the observer that we toggled softkey visibility by 
        // pressing selection key
        iObserver.EngineToggleUiStateL();
        
    }

// -----------------------------------------------------------------------------
// VolumeUpL
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::VolumeUpL()
	{
	TRACER("CShwSlideshowEngineImpl::VolumeUpL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::VolumeUpL" );

	// check state and send the resume event to the router
	if( CShwSlideshowEngine::EShwStateInitialized != iState )
		{
		TShwEventVolumeUp volumeUp;
		SendEventL( &volumeUp );
		}
	}

// -----------------------------------------------------------------------------
// VolumeDownL
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::VolumeDownL()
	{
	TRACER("CShwSlideshowEngineImpl::VolumeDownL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::VolumeDownL" );

	// check state and send the resume event to the router
	if( CShwSlideshowEngine::EShwStateInitialized != iState )
		{
		TShwEventVolumeDown volumeDown;
		SendEventL( &volumeDown );
		}
	}


// -----------------------------------------------------------------------------
// ResumeL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::ResumeL()
	{
	TRACER("CShwSlideshowEngineImpl::ResumeL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::ResumeL" );

	// check state and send the resume event to the router
	if ( iState == CShwSlideshowEngine::EShwStatePaused )
		{
		// only valid to resume if we're currently paused
		TShwEventResume resumeEvent;
		SendEventL( &resumeEvent );

		// update the state
		iState = CShwSlideshowEngine::EShwStateRunning;
		
		// tell the observer that the show restarted
		iObserver.EngineResumedL();
		}
	}

// -----------------------------------------------------------------------------
// NotifyL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::NotifyL( MShwEvent* aEvent )
	{
	TRACER("CShwSlideshowEngineImpl::NotifyL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::NotifyL" );

	// we got an event, was it ready to view and we are not yet running
	if( ( CShwSlideshowEngine::EShwStateInitialized == iState ) &&
	    ( dynamic_cast< TShwEventReadyToView* >( aEvent ) ) )
		{
    	GLX_LOG_INFO( "CShwSlideshowEngineImpl::send TShwEventStart" );
		// start the playback
		TShwEventStart start;
		SendEventL( &start );
		
		// set state
		iState = CShwSlideshowEngine::EShwStateRunning;
		
		// tell the observer that we are running the show
		iObserver.EngineStartedL();

		// show the control group on the display.
		ShwUiUtility::ShowVisualListL( iDisplay, iVisualList );
		}
	else if( dynamic_cast< TShwEventFatalError* >( aEvent ) )
	    {
    	GLX_LOG_INFO( "CShwSlideshowEngineImpl fatal error, exit slideshow" );
        // let the observer close down slideshow
        iObserver.ErrorDuringSlideshowL();
	    }
	else if( dynamic_cast< TShwEventToggleControlUi* >( aEvent ) )
        {
        GLX_LOG_INFO( "CShwSlideshowEngineImpl:NotifyL - TShwEventToggleControlUi" );
        // Have to impliment if need comes
        }
	}

// -----------------------------------------------------------------------------
// State.
// -----------------------------------------------------------------------------	
CShwSlideshowEngine::TShwState CShwSlideshowEngineImpl::State() const
	{
	TRACER("CShwSlideshowEngineImpl::State()");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::State()" );
	return iState;
	}

// -----------------------------------------------------------------------------
// AvailableEffectsL.
// -----------------------------------------------------------------------------
void CShwSlideshowEngineImpl::AvailableEffectsL(
	RArray<TShwEffectInfo>& aEffects )
	{
	TRACER("CShwSlideshowEngineImpl::AvailableEffectsL");
	GLX_LOG_INFO( "CShwSlideshowEngineImpl::AvailableEffectsL" );
	// This should be queried from the playback factory
	CShwPlaybackFactory::AvailableEffectsL( aEffects );
	}