/*

* Copyright (c) 2006 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:   Transition effect framework

*

*/

#include "alflogger.h"

#include "alf/alfappserver.h"

#include "alf/alfappui.h"

#include "alf/alfconstants.h"

#include "alfsrvdisplaysubsession.h"

#include "alfsrvcontrolgroupsubsession.h"

#include "alfsrvsettingshandler.h"

#include <coemain.h>

#include <mm/mmcleanup.h>

#include <pslninternalcrkeys.h>

#include <centralrepository.h>

#include <akntranseffect.h> 

#include <uiacceltk/HuiControl.h>

#include <uiacceltk/HuiControlGroup.h>

#include <uiacceltk/HuiDisplay.h>

#include <uiacceltk/HuiDisplayCoeControl.h>

#include <uiacceltk/HuiEnv.h>

#include <uiacceltk/HuiTextVisual.h>

#include <uiacceltk/HuiTransformation.h>

#include <uiacceltk/HuiBorderBrush.h>

#include <uiacceltk/HuiImageVisual.h>

#include <uiacceltk/HuiGridLayout.h>

#include <uiacceltk/HuiTextureProcessor.h>

#include <uiacceltk/HuiSegmentedTexture.h>

#include "alfsrvtranseffect.h"

// ============================ LOCAL CLASS ===============================

/**

 * This helper class implements listener for any CenRep key. 

 *

 */

NONSHARABLE_CLASS( CAlfCenRep ) : public CActive

    {

public:  // New  

    static CAlfCenRep* NewL( TInt aPriority, const TUid& aRepository, TUint32 aKey );

    ~CAlfCenRep();

    /**

     * Gets the current stored value of the key.

     */

    TInt GetValue( TInt& aValue );

private: // From CActive

    void RunL();

    void DoCancel();

private: // New

    CAlfCenRep( TInt aPriority, const TUid& aRepository, TInt aKey );

    void ConstructL();

private: // Data

	CRepository *iCenRep;

    TUid iRepository;

    TInt iKey;

    TInt iValue;

    TInt iError;

    };

// ============================ LOCAL CLASS MEMBER FUNCTIONS ================

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

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

//

CAlfCenRep::CAlfCenRep( TInt aPriority, const TUid& aRepository, TInt aKey ) :

    CActive( aPriority ),

    iRepository( aRepository ),

    iKey( aKey )

    {

    }

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

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

//

void CAlfCenRep::ConstructL()

    {

    iCenRep = CRepository::NewL( iRepository );

    CActiveScheduler::Add( this );

    RunL();

    }

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

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

//

CAlfCenRep* CAlfCenRep::NewL( TInt aPriority, const TUid& aRepository, TUint32 aKey )

    {

    CAlfCenRep* self = new (ELeave) CAlfCenRep( aPriority, aRepository, aKey );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

CAlfCenRep::~CAlfCenRep()

    {

    Cancel();

    delete iCenRep;

    }

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

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

//

void CAlfCenRep::RunL()

    {

    TInt value;

    iError = iCenRep->Get( iKey, value );

    if( iError == KErrNone )

    	{

    	iValue = value;

    	}

    iError = iCenRep->NotifyRequest( iKey, iStatus );

    if( iError == KErrNone )

    	{

    	SetActive();

    	}

    }

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

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

//

TInt CAlfCenRep::GetValue( TInt& aValue )

	{

	if(iError != KErrNone) //if we had an error eariler

		{

		TInt value;

		iError = iCenRep->Get( iKey, value ); //try to get the value

		if(iError == KErrNone)

			{

			iValue = value;

			iError = iCenRep->NotifyRequest( iKey, iStatus ); //try to start request

			if(iError == KErrNone)

				{

				SetActive();

				}

			}

		}

	aValue = iValue;

	return iError;

	}

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

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

//

void CAlfCenRep::DoCancel()

    {

    iCenRep->NotifyCancel( iKey );

    }

// ======== MEMBER FUNCTIONS ========

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

// Constructors

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

//

CAlfSrvTransEffect::CAlfSrvTransEffect()

    {

    }

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

// 

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

//

CAlfSrvTransEffect* CAlfSrvTransEffect::NewL()

    {

    CAlfSrvTransEffect* me = new (ELeave) CAlfSrvTransEffect();

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop();

    return me;

    }

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

// 

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

//

void CAlfSrvTransEffect::ConstructL()

    {    

    // Load transition effect plugins

	PopulateEffectArrayL();

    if (iEffectPlugins.Count() > 0)

    	{

    	iIsEnabled = ETrue;

    	}

    // Start listening Avkon effect system state 

    iAvkonTfxStateListener = CAlfCenRep::NewL( 

    	EPriorityHigh, KCRUidThemes, KThemesTransitionEffects );   

    }

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

// Destructor

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

//

CAlfSrvTransEffect::~CAlfSrvTransEffect()

    {

    delete iAvkonTfxStateListener;

	iEffectPlugins.ResetAndDestroy();

	iEffectMap.Close();

   	REComSession::FinalClose(); 

    }

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

// Get a list of plugin implementations via ECom, construct the plugins and 

// add them to the array.

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

//

void CAlfSrvTransEffect::PopulateEffectArrayL()

	{

	// Get a list of all plugins from ECom

	TEComResolverParams resolverParams;

	resolverParams.SetDataType ( KAlfTransEffectPluginTypeStringDesc );

	resolverParams.SetWildcardMatch ( EFalse );

	RImplInfoPtrArray implInfoArray;

	REComSession::ListImplementationsL( KAlfTransEffectPluginInterfaceUid, 

		resolverParams, implInfoArray );

	CleanupResetAndDestroyPushL( implInfoArray ); // Note: intentionally called only after ListImplementationsL()

	__ALFLOGSTRING1("ALF: CAlfSrvTransEffect::PopulateExtensionArrayL(): extension count: %d",

		implInfoArray.Count())

	// Create each plugin via ECom and add it to the list 

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

		{		

		MAlfTransEffectPlugin* plugin = NULL;

		// Trap the construction as if one plugin fails to construct it 

		// should not stop others from constructing

		TRAPD( error, plugin = reinterpret_cast <MAlfTransEffectPlugin*> ( REComSession::CreateImplementationL( 

			implInfoArray[i]->ImplementationUid(), _FOFF (MAlfTransEffectPlugin, iDtor_ID_Key) ) ) );

		TInt countAddedEffects = 0;

		if ( !error && ( plugin != NULL ) )

			{

			RArray<TInt> effectIds;

			CleanupClosePushL( effectIds );

			plugin->GetSupportedEffects( effectIds );

			TInt count = effectIds.Count();

			if ( count > 0 )

				{

				for ( TInt ii = 0; ii < count; ii++ )

					{

					TInt mapError = iEffectMap.InsertInSignedKeyOrder( CAlfSrvTransEffect::TEffectMapItem( effectIds[ii], plugin ) );

					if ( mapError == KErrNone ) 

						{

						countAddedEffects++;

						}

					else // You cannot insert duplicate effects (with same effect ID)

						{

						__ALFLOGSTRING3("Alf: CAlfSrvTransEffect::PopulateExtensionArrayL. Cannot insert effect id to the map array. Imp.uid=%d, effect id=%d, error=%d", 						

							implInfoArray[i]->ImplementationUid().iUid, effectIds[ii], error)

						}

					}

				}

			CleanupStack::PopAndDestroy( &effectIds );

			}

		// Add plugin to the array if it has at least one effect that has been

		// successfully registered.	

		if ( !error && ( plugin != NULL ) && ( countAddedEffects > 0 ) )

			{

			iEffectPlugins.AppendL( plugin );

			}

		else

			{

			// If the plugin is failing we skip that.

			__ALFLOGSTRING3("Alf: CAlfSrvTransEffect::PopulateExtensionArrayL. Cannot add plugin, uid=%d, error=%d, plugin=%d", 

				implInfoArray[i]->ImplementationUid().iUid, error, plugin )

			__ALFLOGSTRING1("                                                  countAddedEffects=%d", 

				countAddedEffects )

			delete( plugin );

			}		

		} // for

	CleanupStack::PopAndDestroy( &implInfoArray );

	}

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

// 

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

//

TBool CAlfSrvTransEffect::IsEnabled()

	{

	TInt value;

	iAvkonTfxStateListener->GetValue( value );

	TBool isAvkonEffectsEnabled = ( value != KMaxTInt );

	return( iIsEnabled &&  !isAvkonEffectsEnabled );

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::StartPhase( 

    TInt aPhaseId, TInt aContext, 

    CAlfSrvEffectEnv& aEffectEnv, 

    TInt /*aUidValue*/, 

    TInt /*aKey*/, 

    TInt /*aUidValue2*/, 

    TInt /*aKey2*/, 

    const TDesC8* aParams)

	{

	if ( IsEnabled() )

		{		

		// Find the plugin which implements the effect related to this context and call it

		MAlfTransEffectPlugin* plugin = NULL;

		if ( FindPlugin( aContext,  &plugin ) == KErrNone )

			{

			// Update state

			iCurrContext = aContext;

			iCurrPhase = aPhaseId;

			// Call plugin

			ASSERT( plugin != NULL );

			plugin->StartPhase( aPhaseId, aContext, aEffectEnv, aParams );

			}

		}

	return KErrNone;	

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::Abort( TInt /*aContext*/, TInt /*aUidValue*/, TInt /*aKey*/ )

	{

	return KErrNone;

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::SetProperty( TInt /*aProperty*/, TInt /*aValue*/, TInt /*aUidValue*/, TInt /*aKey*/ )

	{

	return KErrNone;

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::GetProperty( TInt /*aProperty*/, TInt& /*aValue*/, TInt /*aUidValue*/, TInt /*aKey*/ )

	{

	return KErrNone;

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::AddEventObserver( MAlfTransEffectObserver* /*aObserver*/, TInt /*aEvents*/, const TDesC8* /*aParams*/ )

	{

	return KErrNone;

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::RemoveEventObserver( MAlfTransEffectObserver* /*aObserver*/, TInt /*aEvents*/ )

	{

	return KErrNone;

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::GetEventState( TInt /*aEvent*/, TInt* /*aState*/, TDes8* /*aParams*/ )

	{

	return KErrNotReady;

	}    

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

// 

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

//

TInt CAlfSrvTransEffect::FindPlugin( TInt aContext, MAlfTransEffectPlugin** aPlugin ) 

	{

	// Note: Now the context id is the same as effect id, but this can change in the future

	CAlfSrvTransEffect::TEffectMapItem item( aContext, NULL );

	TInt index;

	if ( iEffectMap.FindInSignedKeyOrder( item, index ) == KErrNone )

		{

		*aPlugin = iEffectMap[index].iPluginPtr;

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}    

// End of file