/*

* 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 playback factory, configures the playback for the slideshow

 *

*/

//  CLASS HEADER

#include "shwplaybackfactory.h"

//  EXTERNAL INCLUDES

#include <mglxvisuallist.h>

#include <ecom/implementationinformation.h>

#include <ecom/ecom.h>

//  INTERNAL INCLUDES

#include <glxlog.h>

#include <glxtracer.h>

#include "shwtimercontrol.h"

#include "shwviewcontrol.h"

#include "shweffectcontrol.h"

#include "shwdefaulteffectmanager.h"

#include "shwcrossfadeeffect.h"

#include "shwzoomandpaneffect.h"

#include "shwmusiccontrol.h"

#include "shwmusicobserver.h"

#include "shwsettingsmodel.h"

#include "shweffectinfo.h"

#include "shwcleanupwrapper.h"

using namespace NShwSlideshow;

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

// Local definitions

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

//

namespace

	{

	// granularity for observer array, typical count

	const TInt KObserverCount = 8;

	// granularity for publisher array, typical count

	const TInt KPublisherCount = 8;

	}

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

// The implementation class

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

//

NONSHARABLE_CLASS( CShwPlaybackFactory::CShwPlaybackFactoryImpl )

	: public CBase

	{

	public:

		/**

		 * Constructors.

		 */

		CShwPlaybackFactoryImpl(MShwMusicObserver& aMusicObserver);

		/**

		 * Destructors.

		 */

		~CShwPlaybackFactoryImpl();

		/**

		 * 2nd stage constructor.

		 * @param aHuiEnv the HUI environment

		 * @param aVisualList the visual list of the show

		 * @param aMediaList  the media list of the show

		 * @param aMusicObserver the music control observer

		 * @param aScreenSize the screen size to use

		 */

		void ConstructL(

			CAlfEnv* aAlfEnv, 

			MGlxVisualList* aVisualList,

			MGlxMediaList* aMediaList, 

			TSize aScreenSize );

	public:

		/// @ref CShwPlaybackFactory::EventObservers

		RPointerArray< MShwEventObserver > EventObservers();

		/// @ref CShwPlaybackFactory::EventPublishers

		RPointerArray< MShwEventPublisher > EventPublishers();

		/// @ref CShwSlideshowEngine::AvailableEffectsL

		// @returns ownership of array of effects

		static void CreateEffectsL( RPointerArray<MShwEffect>& aEffects );

	private:

		/// Own: Effect manager

		CShwDefaultEffectManager* iEffectManager;

		/// Own: Timer control

		CShwTimerControl* iTimerControl;

		/// Own: Music control

		CShwMusicControl* iMusicControl;

		/// Own: Effect control

		CShwEffectControl* iEffectControl;

		/// Own: View control

		CShwViewControl* iViewControl;

		/// Own: the observers

		RPointerArray< MShwEventObserver > iObservers;

		/// Own: the publishers

		RPointerArray< MShwEventPublisher > iPublishers;

		/// Ref: the visual list

		MGlxVisualList* iVisualList;

		/// Ref: the music control observer

		MShwMusicObserver& iMusicObserver;

	};

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

// C++ Constructor. Save a few bits of rom with inlining

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

inline CShwPlaybackFactory::CShwPlaybackFactory() 

	{

	// No implementation needed

	}

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

// NewL. Static construction

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

CShwPlaybackFactory* CShwPlaybackFactory::NewL(

	CAlfEnv* aAlfEnv,

	MGlxVisualList* aVisualList,

	MGlxMediaList* aMediaList,

	MShwMusicObserver& aMusicObserver, 

	TSize aScreenSize )

	{

	TRACER("CShwPlaybackFactory::NewL");

	GLX_LOG_INFO( "CShwPlaybackFactory::NewL" );

	CShwPlaybackFactory* self = new( ELeave ) CShwPlaybackFactory( );

	CleanupStack::PushL( self );

	// create the implementation, forward the parameters

	self->iImpl = new( ELeave ) CShwPlaybackFactoryImpl (aMusicObserver);

	self->iImpl->ConstructL( aAlfEnv, aVisualList, aMediaList, aScreenSize );

	CleanupStack::Pop( self );

	return self;

	}

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

// Destructor.

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

CShwPlaybackFactory::~CShwPlaybackFactory()

	{

	TRACER("CShwPlaybackFactory::~CShwPlaybackFactory");

	GLX_LOG_INFO("CShwPlaybackFactory::~CShwPlaybackFactory");

	delete iImpl;

	}

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

// EventObservers.

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

RPointerArray< MShwEventObserver > CShwPlaybackFactory::EventObservers()

	{

	TRACER("CShwPlaybackFactory::EventObservers");

	GLX_LOG_INFO("CShwPlaybackFactory::EventObservers");

	return iImpl->EventObservers();

	}

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

// EventPublishers.

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

RPointerArray< MShwEventPublisher > CShwPlaybackFactory::EventPublishers()

	{

	TRACER("CShwPlaybackFactory::EventPublishers");

	GLX_LOG_INFO("CShwPlaybackFactory::EventPublishers");

	return iImpl->EventPublishers();

	}

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

// AvailableEffectsL

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

void CShwPlaybackFactory::AvailableEffectsL( RArray<TShwEffectInfo>& 

																aEffectInfos )

    {

    TRACER("CShwPlaybackFactory::AvailableEffectsL");

    GLX_LOG_INFO("CShwPlaybackFactory::AvailableEffectsL");

    aEffectInfos.Reset();

    RPointerArray<MShwEffect> effects;

    // put the array in cleanupstack in case effect construction leaves

	ShwCleanupResetAndDestroyPushL( effects );

    CShwPlaybackFactoryImpl::CreateEffectsL( effects );

    TInt i = effects.Count();

    while (i-- > 0)

        {

        // get the effect info and append it to the given array

        aEffectInfos.AppendL( effects[i]->EffectInfo() );

        }

	// ownership transferred, remove array from stack

	CleanupStack::PopAndDestroy( &effects );

    }

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

// CShwPlaybackFactoryImpl

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

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

// C++ Constructor. Save a few bits of rom with inlining

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

inline CShwPlaybackFactory::CShwPlaybackFactoryImpl::CShwPlaybackFactoryImpl(

												MShwMusicObserver& aMusicObserver)

						   : iObservers( KObserverCount ), 

						   	 iPublishers( KPublisherCount ),

						   	 iMusicObserver (aMusicObserver)

	{

	TRACER("CShwPlaybackFactory::CShwPlaybackFactoryImpl::CShwPlaybackFactoryImpl");

	GLX_LOG_INFO("CShwPlaybackFactory::CShwPlaybackFactoryImpl::CShwPlaybackFactoryImpl");

	}

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

// Destructor. Save a few bits of rom with inlining

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

inline CShwPlaybackFactory::CShwPlaybackFactoryImpl::~CShwPlaybackFactoryImpl()

	{

	TRACER("CShwPlaybackFactory::CShwPlaybackFactoryImpl::~CShwPlaybackFactoryImpl");

	GLX_LOG_INFO("CShwPlaybackFactory::CShwPlaybackFactoryImpl::~CShwPlaybackFactoryImpl");

	delete iEffectManager;

	delete iTimerControl;

	delete iMusicControl;

	delete iEffectControl;

	delete iViewControl;

	iObservers.Close();

	iPublishers.Close();

	}

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

// CShwPlaybackFactoryImpl::ConstructL

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

void CShwPlaybackFactory::CShwPlaybackFactoryImpl::ConstructL(

	CAlfEnv* aAlfEnv, 

	MGlxVisualList* aVisualList, 

	MGlxMediaList* aMediaList, 

	TSize aScreenSize )

	{

	TRACER("CShwPlaybackFactory::CShwPlaybackFactoryImpl::ConstructL");

	GLX_LOG_INFO( "CShwPlaybackFactoryImpl::ConstructL" );

	// create the effect manager

	iEffectManager = CShwDefaultEffectManager::NewL();

	// create array for effects

    RPointerArray< MShwEffect > effects;

    // put the array in cleanupstack in case CreateEffectsL leaves

	ShwCleanupResetAndDestroyPushL( effects );

	// create the effects

    CShwPlaybackFactoryImpl::CreateEffectsL( effects );

    // need to go from last to first as we remove items

    TInt i = effects.Count();

    while (i-- > 0)

        {

		effects[ i ]->InitializeL( 

		    aAlfEnv, aVisualList, aMediaList,

		    aScreenSize );

		// give the effect to the manager, it takes ownership

		iEffectManager->AddEffectL( effects[ i ] );

		// remove the effect from original array to prevent

		// double delete, effect manager takes care of the effect from now on

		effects.Remove( i );

        }

	// ownership transferred, remove array from stack

	CleanupStack::Pop( &effects );

	// need to also close the array in this case, this frees the array memory

	effects.Close();

	// create the model to retrieve the persisted slideshow settings. 

	CShwSettingsModel* shwSettingsMdl = CShwSettingsModel::NewL();

	CleanupStack::PushL( shwSettingsMdl );

	// retrieve and set the persisted effect settings

	TShwEffectInfo effect;

	shwSettingsMdl->TransitionTypeL( 

	    effect.iId.iPluginUid, effect.iId.iIndex );

	iEffectManager->SetDefaultEffectL( effect );

	// create the timer

	iTimerControl = CShwTimerControl::NewL();

	iObservers.AppendL( iTimerControl );

	iPublishers.AppendL( iTimerControl );

	// create effect control

	iEffectControl =

		CShwEffectControl::NewL(

		    *iEffectManager, *aVisualList, *aMediaList, aScreenSize );

	iObservers.AppendL( iEffectControl );

	iPublishers.AppendL( iEffectControl );

	// create view manager, view duration is stored in seconds so need to

	// multiply with 1000

	TInt viewDuration = shwSettingsMdl->TransDelayL() * 1000;

	iViewControl = 

		CShwViewControl::NewL( 

		    *aMediaList, KDefaultTransitionDuration, viewDuration );

	iObservers.AppendL( iViewControl );

	iPublishers.AppendL( iViewControl );

    // create music control last as it is the least important

	if (shwSettingsMdl->MusicOnL() )

		{

		// retrieve the name of the music file

		TFileName fileName;

		shwSettingsMdl->MusicNamePathL( fileName );

		// instantiate and initialise the music player

		iMusicControl = CShwMusicControl::NewL(iMusicObserver, fileName );

		iObservers.AppendL( iMusicControl );

		iPublishers.AppendL( iMusicControl );

		}

	CleanupStack::PopAndDestroy( shwSettingsMdl );

	GLX_LOG_INFO( "CShwPlaybackFactoryImpl::ConstructL ended" );

	}

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

// CShwPlaybackFactoryImpl::EventObservers

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

RPointerArray<MShwEventObserver> 

		CShwPlaybackFactory::CShwPlaybackFactoryImpl::EventObservers()

	{

	return iObservers;

	}

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

// CShwPlaybackFactoryImpl::EventPublishers

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

RPointerArray<MShwEventPublisher> 

		CShwPlaybackFactory::CShwPlaybackFactoryImpl::EventPublishers()

	{

	TRACER("CShwPlaybackFactory::CShwPlaybackFactoryImpl::EventPublishers");

	GLX_LOG_INFO( "CShwPlaybackFactoryImpl::EventPublishers" );

	return iPublishers;

	}

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

// CShwPlaybackFactoryImpl::CreateEffectsL

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

void CShwPlaybackFactory::CShwPlaybackFactoryImpl::CreateEffectsL(

											RPointerArray<MShwEffect>& aEffects )

    {

    TRACER("CShwPlaybackFactory::CShwPlaybackFactoryImpl::CreateEffectsL");

	GLX_LOG_INFO( "CShwPlaybackFactoryImpl::CreateEffectsL" );

	aEffects.AppendL( CShwZoomAndPanEffect::NewLC() );

	CleanupStack::Pop(); // CShwZoomAndPanEffect::NewLC()

	aEffects.AppendL( CShwCrossFadeEffect::NewLC() );

	CleanupStack::Pop(); // CShwCrossFadeEffect::NewLC()

    }