/*

* Copyright (c) 2007-2007 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:   Test for slideshow engine

 *

*/

//  CLASS HEADER

#include "t_cshwslideshowengine.h"

//	CLASS UNDER TEST

#include "shwslideshowengineimpl.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/EUnitMacros.h>

#include <digia/eunit/EUnitDecorators.h>

#include <uiacceltk/huiEnv.h>

#include <uiacceltk/huiDisplay.h>

//  INTERNAL INCLUDES

#include "shwslideshowenginepanic.h"

#include "shwhuiutility.h"

#include "shwtimercontrol.h"

#include "shwmusiccontrol.h"

#include "shwviewcontrol.h"

#include "shweffectcontrol.h"

#include "shweffect.h"

#include "shwevent.h"

//	STUBS

#include "tmglxvisuallist_adapter.h"

#include "stub_glxfetchcontexts.h"

#include "stub_mshweffect.h"

class T_Scheduler : public CActiveScheduler

	{

	public:

		// replace the default scheduler behaviour (which is to panic on error)

		void Error( TInt aError ) const

			{

			// we got an error, leave to previous TRAP (that is in alloc decorator)

			User::Leave( aError );

			}

	};

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

// Stub for NShwEngine::Panic -->

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

TBool gNShwEnginePanicCalled = EFalse;

namespace NShwEngine

	{

	extern void Panic( TShwEnginePanic aPanic )

	    {

	    gNShwEnginePanicCalled = ETrue;

	    // in test situation just do a leave

	    User::Leave( aPanic );

	    }

	}

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

// <-- Stub for NShwEngine::Panic

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

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

// Stub for CGlxVisualListManager -->

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

MGlxVisualList_Observer* gVisualListObserver;

TBool gVisualListWasAllocated = EFalse;

TBool gVisualListWasReleased = EFalse;

TBool gVisualListManagerWasDeleted = EFalse;

TInt gVisualListInitialFocus = 2;

class CGlxVisualListManager : public CBase

	{

	public:

		CGlxVisualListManager();

		static CGlxVisualListManager* ManagerL();

		~CGlxVisualListManager();

		MGlxVisualList* AllocListL(

			MGlxMediaList* aItemList, 

    		CHuiEnv& aEnv, CHuiDisplay& aDisplay,

    		CHuiImageVisual::TScaleMode aThumbnailScaleMode = CHuiImageVisual::EScaleFitInside );

		void ReleaseList( MGlxVisualList* aList );

		void Close();

	private:

		TMGlxVisualList_Adapter iList;

	};

CGlxVisualListManager::CGlxVisualListManager()

	: iList( gVisualListObserver )

	{

	}

CGlxVisualListManager::~CGlxVisualListManager()

	{

	gVisualListManagerWasDeleted = ETrue;

	}

CGlxVisualListManager* CGlxVisualListManager::ManagerL()

	{

	return new( ELeave ) CGlxVisualListManager;

	}

MGlxVisualList* CGlxVisualListManager::AllocListL(

	MGlxMediaList* , 

	CHuiEnv& , 

	CHuiDisplay& ,

	CHuiImageVisual::TScaleMode  )

	{

	gVisualListWasAllocated = ETrue;

	// set the size and initial focus of the visual list

	iList.iFocus = gVisualListInitialFocus;

	EUNIT_PRINT( _L("Visual list initial focus %d"), iList.iFocus );

	// this is just long enough not to complicate the test 

	iList.iSize = 100;

	return &iList;

	}

void CGlxVisualListManager::ReleaseList( MGlxVisualList* /*aList*/ )

	{

	gVisualListWasReleased = ETrue;

	}

void CGlxVisualListManager::Close()

	{

	delete this;

	}

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

// <-- Stub for CGlxVisualListManager

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

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

// Stub for CShwPlaybackFactory -->

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

#include "shwplaybackfactory.h"

TBool gPlaybackFactoryWasDeleted = EFalse;

// static arrays for the observers and publishers

RPointerArray< MShwEventObserver > gEventObservers;

RPointerArray< MShwEventPublisher > gEventPublishers;

// array of available effects info

RArray<TShwEffectInfo> gEffects;

MShwEffectManager* gEffectManager = NULL;

CShwTimerControl* gTimerControl = NULL;

CShwMusicControl* gMusicControl = NULL;

CShwEffectControl* gEffectControl = NULL;

CShwViewControl* gViewControl = NULL;

TBool gIncludeMusicControl = EFalse;	// by default no music

TBool gSetRealSong = ETrue;    // by default set real song

namespace

	{

	// NOTE these values work with the current test configuration

	// if you change these some async tests may fail

	// default transition duration, milliseconds

	const TInt KDefaultTransitionDuration = 100;

	// default view duration, milliseconds

	const TInt KDefaultViewDuration = 150;

	}

CShwPlaybackFactory* CShwPlaybackFactory::NewL(

	CHuiEnv* /*aHuiEnv*/, 

	MGlxVisualList* aVisualList, 

	MGlxMediaList* aMediaList,

	MShwMusicObserver& aMusicObserver,

	TSize aScreenSize )

	{

	CShwPlaybackFactory* self = new( ELeave ) CShwPlaybackFactory;

	CleanupStack::PushL( self );

	// create the event classes

	// create the timer

	gTimerControl = CShwTimerControl::NewL();

	gEventObservers.AppendL( gTimerControl );

	gEventPublishers.AppendL( gTimerControl );

	// include music control only if wanted

	if( gIncludeMusicControl )

		{

		// create the music control

		_LIT(KTempFileName, "c:\\knightrider.mp3");

		if( gSetRealSong )

		    {

    		gMusicControl = CShwMusicControl::NewL( aMusicObserver, KTempFileName );

		    }

		else

		    {

    		gMusicControl = CShwMusicControl::NewL( aMusicObserver, KNullDesC );

		    }

		gEventObservers.AppendL( gMusicControl );

		gEventPublishers.AppendL( gMusicControl );

		}

	// create effect manager	

	gEffectControl = 

		CShwEffectControl::NewL( 

		    *gEffectManager, *aVisualList, *aMediaList, aScreenSize );

	gEventObservers.AppendL( gEffectControl );

	gEventPublishers.AppendL( gEffectControl );

	// create view manager

	gViewControl = 

		CShwViewControl::NewL(

			*aMediaList, KDefaultTransitionDuration, KDefaultViewDuration );

	gEventObservers.AppendL( gViewControl );

	gEventPublishers.AppendL( gViewControl );

	CleanupStack::Pop( self );

	return self;

	}

CShwPlaybackFactory::~CShwPlaybackFactory()

	{

	gPlaybackFactoryWasDeleted = ETrue;

	// delete the event objects

	delete gTimerControl;

	delete gMusicControl;

	delete gEffectControl;

	delete gViewControl;

	gEventObservers.Close();

	gEventPublishers.Close();

	gEffects.Close();

	}

CShwPlaybackFactory::CShwPlaybackFactory()

	{

	gTimerControl = NULL;

	gMusicControl  = NULL;

	gEffectControl = NULL;

	gViewControl = NULL;

	}

RPointerArray< MShwEventObserver > CShwPlaybackFactory::EventObservers()

	{

	return gEventObservers;

	}

RPointerArray< MShwEventPublisher > CShwPlaybackFactory::EventPublishers()

	{

	return gEventPublishers;

	}

void CShwPlaybackFactory::AvailableEffectsL(RArray<TShwEffectInfo>& aEffects)

	{

	aEffects = gEffects;

	}

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

// <-- Stub for CShwPlaybackFactory

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

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

// Stub for ShwHuiUtility -->

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

void ShwHuiUtility::ShowVisualListL(

	CHuiDisplay* /*aDisplay*/, MGlxVisualList* /*aVisualList*/ )

	{

	// do nothing

	}

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

// <-- Stub for ShwHuiUtility

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

// CONSTRUCTION

T_CShwSlideshowEngine* T_CShwSlideshowEngine::NewL()

	{

	T_CShwSlideshowEngine* self = T_CShwSlideshowEngine::NewLC();

	CleanupStack::Pop();

	return self;

	}

T_CShwSlideshowEngine* T_CShwSlideshowEngine::NewLC()

	{

	T_CShwSlideshowEngine* self = new( ELeave ) T_CShwSlideshowEngine;

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// Destructor (virtual by CBase)

T_CShwSlideshowEngine::~T_CShwSlideshowEngine()

	{

	// remove our scheduler

	// replace old with our new

	iScheduler->Replace( iOldScheduler );

	delete iScheduler;

	delete iTimer;

	}

// Default constructor

T_CShwSlideshowEngine::T_CShwSlideshowEngine()

	{

	}

// Second phase construct

void T_CShwSlideshowEngine::ConstructL()

	{

	// The ConstructL from the base class CEUnitTestSuiteClass must be called.

	// It generates the test case table.

	CEUnitTestSuiteClass::ConstructL();

	// remove the old scheduler

	iOldScheduler = CActiveScheduler::Current();

	// create our own scheduler

	iScheduler = new( ELeave ) T_Scheduler;

	// replace old with our new

	iOldScheduler->Replace( iScheduler );

	}

//  METHODS

TBool gObserverEngineStarted = EFalse;

void T_CShwSlideshowEngine::EngineStartedL()

	{

	gObserverEngineStarted = ETrue;

	}

TBool gObserverEnginePaused = EFalse;

void T_CShwSlideshowEngine::EnginePausedL()

	{

	gObserverEnginePaused = ETrue;

	}

TBool gObserverEngineResumed = EFalse;

void T_CShwSlideshowEngine::EngineResumedL()

	{

	gObserverEngineResumed = ETrue;

	}

TBool gObserverEngineError = EFalse;

void T_CShwSlideshowEngine::ErrorDuringSlideshowL()

    {

    gObserverEngineError = ETrue;

    }

void T_CShwSlideshowEngine::MGlxMediaList_MethodCalled( TMGlxMediaListMethodId aMethodId )

	{

	// append the methodid in the array

	TInt error = iMediaListCalls.Append( aMethodId );

	// check that append succeeded

	if( error != KErrNone )

		{

		// critical error, not enough space to append messages

		User::Panic( _L("T_CShwSlideshowEngine::MGlxMediaList_MethodCalled"), __LINE__ );

		}

	}

void T_CShwSlideshowEngine::MGlxVisualList_MethodCalled( TMGlxVisualListMethodId aMethodId )

	{

	// append the methodid in the array

	TInt error = iVisualListCalls.Append( aMethodId );

	// check that append succeeded

	if( error != KErrNone )

		{

		// critical error, not enough space to append messages

		User::Panic( _L("T_CShwSlideshowEngine::MGlxVisualList_MethodCalled"), __LINE__ );

		}

	}

// From MShwEffectManager >>

void T_CShwSlideshowEngine::AddEffectL( MShwEffect* /*aEffect*/ )

	{

	// this is not called in this test

	}

MShwEffect* T_CShwSlideshowEngine::CurrentEffect()

	{

	switch( iCurrentEffect )

		{

		case 0 : return iEffect1;

		case 1 : return iEffect2;

		case 2 : return iEffect3;

		// default falls through

		}

	return NULL;

	}

MShwEffect* T_CShwSlideshowEngine::Effect( TInt aDirection )

	{

	TInt index = iCurrentEffect + aDirection;

	switch( index )

		{

		case -1 : return iEffect3;

		case 0 : return iEffect1;

		case 1 : return iEffect2;

		case 2 : return iEffect3;

		case 3 : return iEffect1;

		// default falls through

		}

	return NULL;

	}

void T_CShwSlideshowEngine::ProceedToEffect( TInt aDirection )

	{

	// inc and modulo with 3 -> values are: 0, 1, 2

	iCurrentEffect += aDirection;

	iCurrentEffect %= 3;

	// if negative, loop back to 2

	if( iCurrentEffect < 0 )

		{

		iCurrentEffect = 2;

		}

	}

void T_CShwSlideshowEngine::SetEffectOrder( MShwEffectManager::TShwEffectOrder /*aOrder*/ )

    {

    }

MShwEffectManager::TShwEffectOrder T_CShwSlideshowEngine::EffectOrder()

    {

    return MShwEffectManager::EEffectOrderProgrammed;

    }

void T_CShwSlideshowEngine::SetProgrammedEffects( RArray< TShwEffectInfo >& /*aEffects*/ )

    {

    }

void T_CShwSlideshowEngine::SetDefaultEffectL(TShwEffectInfo /*aInfo*/)

    {

    }

void T_CShwSlideshowEngine::GetActiveEffectsL( RPointerArray< MShwEffect >& /*aEffects*/ )

	{

	}

// << from MShwEffectManager

// flag for resetting the thumbnail context request count

TBool gResetThumbnailContextRequestCount = EFalse;

void T_CShwSlideshowEngine::NotifyL( MShwEvent* aEvent )

	{

	// got event so add a copy of it to the list 

	TInt error = iEvents.Append( aEvent->CloneLC() );

	CleanupStack::Pop();

	// check that append succeeded

	if( error != KErrNone )

		{

		// critical error, not enough space to append events

		User::Panic( _L("T_CShwSlideshowEngine::NotifyL"), __LINE__ );

		}

	// if we received init completed we might want to reset the 

	// thumbnail stub to tell that it has panding requests

	if( gResetThumbnailContextRequestCount &&

		dynamic_cast<TShwEventReadyToView*>( aEvent ) )

		{

		gThumbnailContextRequestCount = 1;

		}

	// if we have waited enough events and wait is active

	iEventsReceived++;

	if( iEventsReceived >= iEventsToWait && iSchedulerWait.IsStarted() )

		{

		iSchedulerWait.AsyncStop();

		}

	}

TInt T_CShwSlideshowEngine::LoadThumbnailL( TAny* aThis )

	{

	T_CShwSlideshowEngine* self = (T_CShwSlideshowEngine*)aThis;

	// notify engine that thumbnail is ready for index, increase the index

	// set the thumbnail request to be complete

	gThumbnailContextRequestCount = KErrNone;

	self->iStubMedialist->NotifyAttributesAvailableL( self->iThumbnailLoadIndex++ );

	// set the thumbnail request to be not complete

	gThumbnailContextRequestCount = 1;

	return 1;

	}

void T_CShwSlideshowEngine::MusicOnL()

	{

	iMusicOn = ETrue;

	}

void T_CShwSlideshowEngine::MusicOff()

	{

	iMusicOn = EFalse;

	}

void T_CShwSlideshowEngine::MusicVolume(TInt aCurrentVolume, TInt aMaxVolume)

	{

	iCurrentVolume = aCurrentVolume;

	iMaxVolume     = aMaxVolume;

	if(iVolumeWait.IsStarted())

		{

		iVolumeWait.AsyncStop();

		}

	}	

void T_CShwSlideshowEngine::ErrorWithTrackL(TInt /*aErrorCode*/)

	{

	}	

// Test methods

void T_CShwSlideshowEngine::EmptyL()

	{

	}

void T_CShwSlideshowEngine::SetupL()

	{

	// reset events received

	iEventsReceived = 0;

	// create thumbnail loader

	iThumbnailLoader = CPeriodic::NewL( 0 ); // default priority

	// create stub list

	iStubMedialist = new( ELeave ) TMGlxMediaList_Stub( this );

	// reset the wait counter

	iEventsToWait = 0;

	iEffect1 = new( ELeave ) T_MShwTestEffect( 1 );

	iEffect2 = new( ELeave ) T_MShwTestEffect( 2 );

	iEffect3 = new( ELeave ) T_MShwTestEffect( 3 );

	// set the test suite as visual list observer

	gVisualListObserver = this;

	// set ourselves as effect manager