/*

* 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:   Alf system effects

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <bitdev.h>

#include <implementationproxy.h>

#include <akntranseffect.h>

#include <pslninternalcrkeys.h>

#include <s32mem.h> //RMemReadStream

#include "alftfxplugincommon.hrh"

#include "alfgfxeffects.h"

#include "alf/alfsrveffectenv.h"

#include "alfstreamerbridge.h"

#include "alfwindowmanager.h"

#include "alfserverdrawer.h"

#include "repositoryhandler.h"

#include "alftfxserverdef.h"

#include "alfpolicyhandler.h"

#include "alflogger.h"

#include "uiacceltk/HuiDisplay.h"

#include "uiacceltk/HuiLayout.h"

#include "uiacceltk/HuiControlGroup.h"

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiRoster.h"

#include "uiacceltk/HuiCommand.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiTransformation.h"

#include "wsserverdrawercontroller.h"

// Constants

//const TInt KAlfDefaultFocusGainedEffectDuration = 500;

//const TInt KAlfDefaultFocusLostEffectDuration = 500;

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

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

// CAlfGfxEffects::CAlfGfxEffects

// C++ constuctor.

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

//

CAlfGfxEffects::CAlfGfxEffects( ) 

    {

    __ALFFXLOGSTRING("CAlfGfxEffects::CAlfGfxEffects");

    }

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

// CAlfGfxEffects::EndExpired

// Timeout for grouped effects, that have not received EndGroup or have received 

// EndGroup with non-existing group id.

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

//

void CAlfGfxEffects::EndExpired( ) 

    {

	TInt count;

	while((count = iActiveSyncronizedGroups.Count() - 1 ) >= 0)

		{

		iEngine->EndSyncronizedGroup(iActiveSyncronizedGroups[count], ETrue /* force removal, running effect should be skipped */);

		iActiveSyncronizedGroups.Remove(count);

		}

    __ALFFXLOGSTRING("CAlfGfxEffects::EndExpired - release all syncronized groups");

    }

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

// CAlfGfxEffects::NewExtensionL

// Two-phased constructor.

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

//

CAlfWindowFxPlugin* CAlfGfxEffects::NewFxPluginL()

    {

    __ALFFXLOGSTRING("CAlfGfxEffects::NewFxPluginL >>");

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

//    do not call constructor here, base class constructor gets called later

    __ALFFXLOGSTRING("CAlfGfxEffects::NewFxPluginL <<");

    return ( self );

    }

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

// CAlfGfxEffects::ConstructL

// 

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

//

void CAlfGfxEffects::ConstructL(const CAlfWindowManager& aMgr, TInt aAlfBufferFormat)

    {

    __ALFFXLOGSTRING("CAlfGfxEffects::ConstructL >>");

    CAlfWindowFxPlugin::ConstructL(aMgr, aAlfBufferFormat);

    // create a policy handler for registering the effect files.

    iPolicyHandler = CPolicyHandler::NewL();

    // create controller and engine

    iEngine = CAlfServerDrawer::NewL( CAlfWindowFxPlugin::WindowManager(), *iPolicyHandler );

    iSysDisable = CRepositoryHandler::NewL(EPriorityHigh + KTfxServerRepositoryHandler, 

	                                     KCRUidThemes, 

	                                     KThemesTransitionEffects);

    iSyncronizedGroupDefitionEndChecker = CEndCheck::NewL(*this);

    __ALFFXLOGSTRING("CAlfGfxEffects::ConstructL <<");

    }

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

// CAlfGfxEffects::~CAlfGfxEffects

// C++ destructor.

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

//

CAlfGfxEffects::~CAlfGfxEffects()

    {

    __ALFFXLOGSTRING("CAlfGfxEffects::~CAlfGfxEffects >>");

    delete iPolicyHandler;

    delete iSysDisable;

    delete iEngine;

    __ALFFXLOGSTRING("CAlfGfxEffects::~CAlfGfxEffects <<");

    }

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

//

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

//

void CAlfGfxEffects::HandleMessageL( const TDesC8& aInBuf, TPtr8& aOutBuf )

    {

    __ALFFXLOGSTRING("CAlfGfxEffects::HandleMessageL >>");

    // synchronous messages are completed by server 

    RDesReadStream inStream;

    inStream.Open( aInBuf );

    TInt err = KErrNone;

    TInt op = inStream.ReadInt32L();

    TUint action = 0;

    TUid uid1( KNullUid );

    TUid uid2( KNullUid );

    HBufC* resourceDir = NULL;

    HBufC* fileName = NULL;

    HBufC* backgroundFileName = NULL;

    TInt wantedTime = 0;

    TInt minTime = 0;

    TThreadId clientThreadId( 0 );

    // These are needed to read the 64 bit thread id from the stream

   	TUint64 id = 0;

    TUint8* ptr = reinterpret_cast<TUint8*>( &id );

    CAlfTransitionServerClient::TListBoxType listBoxType = CAlfTransitionServerClient::EListTypeAny;

    TInt value = 0;

	TInt error = iSysDisable->GetValue(value);

    RMemWriteStream outStream; // for return values

    TBool fillOutStream = ETrue; // most functions put the error into outbuffer

    // The engine reservers the windows if needed, it first runs all the checks

    // to see if the effects are allowed (effects are not done for some combinations)

    __ALFFXLOGSTRING2("CAlfGfxEffects::HandleMessageL - Operation: %d, Action: %d", op, action );

    __ALFFXLOGSTRING2("CAlfGfxEffects::HandleMessageL - Dir: %S, File: %S", &resourceDir, &fileName );

    switch ( op )

        {

        // full screen transitions

        case MAlfGfxEffectPlugin::EBeginFullscreen:

    	    if((error != KErrNone) || (value & AknTransEffect::EFullScreenTransitionsOff)) 

	    	    {

		        // fullscreen effects are turned off

		        // Should we return the error in aOutBuf?

		        // We should not get end full screen if the effect has not been even started

		        // (could return KErrAbort in aOutBuf)

		        err = KErrAbort;

		        break;

		        }

		    else

		        {

	            action = inStream.ReadUint32L();

#ifdef _DEBUG    

    PrintRequestInfo( op, action);

#endif    

	            TRect effectRect( inStream.ReadInt32L(),

                    inStream.ReadInt32L(), inStream.ReadInt32L(), inStream.ReadInt32L() );

                TInt type = inStream.ReadInt32L();

                // Depending on type, the rest of the parameters have different meaning

                uid1 = TUid::Uid( inStream.ReadInt32L() );

                uid2 = TUid::Uid( inStream.ReadInt32L() );

                TInt data = inStream.ReadInt32L();

                iEngine->BeginFullscreen( action, effectRect, type,

                    uid1, uid2, data );

		        }

            break;

        case MAlfGfxEffectPlugin::EEndFullscreen:

#ifdef _DEBUG    

    PrintRequestInfo( op, action);

#endif    

            iEngine->EndFullscreen();

            break;

        case MAlfGfxEffectPlugin::EAbortFullscreen:

#ifdef _DEBUG    

    PrintRequestInfo( op, action);

#endif    

            iEngine->AbortFullscreen();

            break;

        // component transitions

        case MAlfGfxEffectPlugin::EBeginComponentTransition: 

            if((error != KErrNone) || (value & AknTransEffect::EComponentTransitionsOff))

                {

                err = KErrAbort;

                break;

                }

            else

                {

                // We may not need all of this, but it is here now just to make sure

                // we have enough information.

                {

                action = inStream.ReadUint32L();

#ifdef _DEBUG    

    PrintRequestInfo( op, action);

#endif    

                uid1 = TUid::Uid( inStream.ReadInt32L() );

                TInt windowGroup = inStream.ReadInt32L();

                TInt windowHandle = inStream.ReadInt32L();

                TBool nLayered = inStream.ReadInt32L();

                uid2 = TUid::Uid( inStream.ReadInt32L() ); // layer type uid

                TInt flags = inStream.ReadInt32L(); // hints

                iEngine->BeginControlTransition( action, uid1, windowGroup, windowHandle );

                }

            break;

            }

        // These are the effect registrations    

        case MAlfGfxEffectPlugin::ETfxServerOpAddFullscreenKML:

        case MAlfGfxEffectPlugin::ETfxServerOpAddFullscreenKMLEx:

            {

            action = inStream.ReadUint32L();

#ifdef _DEBUG    

    PrintRequestInfo( op, action);

#endif    

            uid1 = TUid::Uid( inStream.ReadInt32L() );

	        inStream.ReadL( ptr, 8 );

	        clientThreadId = id;

            resourceDir = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( resourceDir );

            fileName = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( fileName );

            // If the operation is ETfxServerOpAddFullscreenKMLEx, there are some more parameters

            TInt cachePriority = -1;

            wantedTime = -1;

            minTime = -1;

            if ( op == ETfxServerOpAddFullscreenKMLEx )

                {

                cachePriority = inStream.ReadInt32L();

                wantedTime = inStream.ReadInt32L();

                minTime = inStream.ReadInt32L();

                }

            err = VerifyResourceLocation( resourceDir->Des() );

            /*

            // Needed to be able to see the filename in carbide

            TPtrC filePtr = fileName->Des();

            RDebug::Print(_L("register file %S"), &filePtr );

            */

            if ( err == KErrNone )

                {

                // register the effect definition file

                if ( uid1.iUid != KAlfAppServerInterfaceUid3 )

                    {

                    TRAP( err, iPolicyHandler->RegisterFullscreenKmlL(

                        action, uid1, clientThreadId, *resourceDir, *fileName,

                        cachePriority, wantedTime, minTime) );

	                iEngine->RegisterAlfFullScreenEffect( action, resourceDir->Des(), fileName->Des() );

                    }

                else

	                {  

	                // effects for KAlfAppServerInterfaceUid3 go directly to Alf Bridge

	                iEngine->RegisterAlfFullScreenEffect( action, resourceDir->Des(), fileName->Des() );

	                }           

                }

            CleanupStack::PopAndDestroy( fileName );

            CleanupStack::PopAndDestroy( resourceDir );

            break;

            }

        case MAlfGfxEffectPlugin::ETfxServerOpRemoveFullscreenKML:

            action = inStream.ReadUint32L();

            uid1 = TUid::Uid( inStream.ReadInt32L() );

            // We don't keep the registration status the files that go directly to alf 

            if ( uid1.iUid != KAlfAppServerInterfaceUid3 )

                {

                err = iPolicyHandler->UnregisterFullscreenKml( action, uid1 );

                }

            else

                {               

                // effects for KAlfAppServerInterfaceUid3 go directly to Alf Bridge

                }        

            iEngine->UnregisterAlfFullScreenEffect( action );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpListBoxRegisterKML:

            uid1 = TUid::Uid( inStream.ReadInt32L() );

	        inStream.ReadL( ptr, 8 );

	        clientThreadId = id;

   	        listBoxType = (CAlfTransitionServerClient::TListBoxType) inStream.ReadInt32L();

            resourceDir = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( resourceDir );

            backgroundFileName = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( backgroundFileName );

            fileName = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( fileName );

            err = VerifyResourceLocation( resourceDir->Des() );

            if ( err == KErrNone )

                {

                iPolicyHandler->RegisterListBoxKmlL( uid1, clientThreadId, listBoxType,

                    *resourceDir, *backgroundFileName, *fileName );

                }

            CleanupStack::PopAndDestroy( fileName );

            CleanupStack::PopAndDestroy( backgroundFileName );

            CleanupStack::PopAndDestroy( resourceDir );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpListBoxUnregisterKML:

            uid1 = TUid::Uid( inStream.ReadInt32L() );

   	        listBoxType = (CAlfTransitionServerClient::TListBoxType) inStream.ReadInt32L();

   	        err = iPolicyHandler->UnregisterListBoxKml( uid1, listBoxType );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpListBoxSetFrameTime:

            iListBoxFrameTime = inStream.ReadInt32L();

            // this must be sent forward somewhere (list controller?)

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpListBoxSetMinFrameTime:

            iListBoxMinFrameTime = inStream.ReadInt32L();

            // this must be sent forward somewhere (list controller?)

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpControlSetFrameTime:

            iControlFrameTime = inStream.ReadInt32L();

            // this must be sent forward somewhere (list controller?)

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpControlSetMinFrameTime:

            iControlMinFrameTime = inStream.ReadInt32L();

            // this must be sent forward somewhere (list controller?)

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpBlockFullscreenUid:

            {

            uid1 = TUid::Uid( inStream.ReadInt32L() );

            TBool blockFrom = inStream.ReadInt32L();

            TBool blockTo = inStream.ReadInt32L();

            err = iPolicyHandler->BlockFullScreenUid( uid1, blockFrom, blockTo );

            break;

            }

        case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyUpdate:

            {

            uid1 = TUid::Uid( inStream.ReadInt32L() );

            TUint actionId = inStream.ReadUint32L();

            HBufC* actionString = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( actionString );

            iPolicyHandler->RegisterControlAction( uid1, actionId, *actionString );

            CleanupStack::PopAndDestroy( actionString );

            break;

            }

        case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyRemove:

            {

            uid1 = TUid::Uid( inStream.ReadInt32L() );

            TUint actionId = inStream.ReadUint32L();

            iPolicyHandler->UnregisterControlAction( uid1, actionId );

            break;

            }

        case MAlfGfxEffectPlugin::ETfxServerOpRegisterControlKml:

        case MAlfGfxEffectPlugin::ETfxServerOpRegisterControlKmlEx:

            uid1 = TUid::Uid( inStream.ReadInt32L() );

	        inStream.ReadL( ptr, 8 );

	        clientThreadId = id;

            resourceDir = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( resourceDir );

            fileName = HBufC::NewL( inStream, 256 );

            CleanupStack::PushL( fileName );

            // If the operation is ETfxServerOpRegisterControlKmlEx, there are some more parameters

            wantedTime = -1;

            minTime = -1;

            if ( op == ETfxServerOpRegisterControlKmlEx )

                {

                wantedTime = inStream.ReadInt32L();

                minTime = inStream.ReadInt32L();

                }

            err = VerifyResourceLocation( resourceDir->Des() );

            if ( err == KErrNone )

                {

                // register the effect definition file

	        	TRAP( err, iPolicyHandler->RegisterControlKmlL(

	        	    uid1, clientThreadId, *resourceDir, *fileName,

	        	    wantedTime, minTime) );

		iEngine->RegisterAlfFullScreenEffect( action, resourceDir->Des(), fileName->Des() );

                }

            CleanupStack::PopAndDestroy( fileName );

            CleanupStack::PopAndDestroy( resourceDir );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpRemoveAllKml:

	        inStream.ReadL( ptr, 8 );

	        clientThreadId = id;

            if ( uid1.iUid != KAlfAppServerInterfaceUid3 )

                {

                err = iPolicyHandler->UnregisterAllKml( clientThreadId );

                }

            else

                {               

                // effects for KAlfAppServerInterfaceUid3 go directly to Alf Bridge

                }   

            iEngine->UnregisterAllAlfFullScreenEffect( );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpRemoveControlKml:

            uid1 = TUid::Uid( inStream.ReadInt32L() );

            err = iPolicyHandler->RemoveControlKml( uid1 );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpSetWantedTime:

            iTransitionTime = inStream.ReadInt32L();

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpSetMinTime:

            iTransitionMinTime = inStream.ReadInt32L();

            break;

        case MAlfGfxEffectPlugin::ETfxServerVerifyConnection:

            // If we get this far, it should prove that we have a good connection

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpFreeRam:

            // here we should return something

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpMemoryGood:

            // here we should return something

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpControlPolicyGet:

            // get the policy structures from the policy handler

            // client id (we don't get the whole message because this is asynchronous

            // We fill the outbuffer with policies, do not add an error afterwards

            {

            fillOutStream = EFalse;

	        inStream.ReadL( ptr, 8 );

	        clientThreadId = id;

            // number of policy structures the return buffer can hold

            TInt count = inStream.ReadInt32L();

            iPolicyHandler->GetPolicyL( clientThreadId, count, aOutBuf );

            break;

            }

        case MAlfGfxEffectPlugin::ETfxServerOpControlCancelPolicyUpdate:

            // cancel any pending policy requests

	        inStream.ReadL( ptr, 8 );

	        clientThreadId = id;

            iPolicyHandler->RemoveClient( clientThreadId );

            break;

        case MAlfGfxEffectPlugin::ETfxServerOpBeginGroup:

        	{

        	TInt groupId= inStream.ReadUint32L();

        	iEngine->BeginSyncronizedGroup(groupId);

        	iActiveSyncronizedGroups.Append(groupId);

        	iSyncronizedGroupDefitionEndChecker->Start(4);

        	break;

        	}

        case MAlfGfxEffectPlugin::ETfxServerOpEndGroup:

			{

			// if all groups have been released, then we can kill the timer.

			if (iActiveSyncronizedGroups.Count() - 1 == 0)

				{

				iSyncronizedGroupDefitionEndChecker->Cancel();

				}

        	TInt groupId= inStream.ReadUint32L();

        	TInt index = iActiveSyncronizedGroups.Find(groupId);

        	if (index!=KErrNotFound)

        		{

				iEngine->EndSyncronizedGroup(groupId);

				iActiveSyncronizedGroups.Remove(index);

        		}

        	if (iActiveSyncronizedGroups.Count())

        		{

				// if there is still groups out there not closed, then this will create timeout for them

				iSyncronizedGroupDefitionEndChecker->Start(4);

        		}

			break;

			}

        default:

            break;

        }

    inStream.Release();

    inStream.Close();    

    if ( aOutBuf.MaxSize() >= sizeof(TInt32) && fillOutStream )

        {

        // The write will not leave as we have checked the length of the buffer beforeahdn

        unsigned char buffer[sizeof(TInt32)];

        outStream.Open( buffer, sizeof(TInt32) );

        outStream.WriteInt32L( err );

        outStream.CommitL();

        outStream.Release();

        outStream.Close();

        aOutBuf.Copy( &buffer[0], sizeof(TInt32) );

        }

    __ALFFXLOGSTRING("CAlfGfxEffects::HandleMessageL <<");

    }

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

//

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

//

void CAlfGfxEffects::HandleMessageL( const TDesC8& aInBuf, const RMessage2& aClientMessage )

    {

    // make sure that there are no pending asynch calls left here

    __ALFFXLOGSTRING1("CAlfGfxEffects::HandleMessageL - : %S", &aInBuf );

    RDesReadStream inStream;

    inStream.Open( aInBuf );