/*

* 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:   Adapter to the GfxTransEffect client. This is the entry point into

*                the Nokia specific parts of the KML transition sollution, from the

*                GfxTransEffect client. 

*

*/

#include <s32mem.h> //RMemReadStream

#include <coecntrl.h>

#include <ecom.h>

#include <akntranseffect.h>

#include <akntransitionutils.h>

#include <avkondomainpskeys.h>

#include <centralrepository.h>

#include <aknlistboxtfxinternal.h> // list box types

#include <eikenv.h>

#include <eikappui.h>

#include <eikapp.h>

#include <eiksrvs.h>

#include "gfxtransenginetfx.h"

#include "e32property.h"

//#include "wstranscontrolgraphic.h"

//#include "wsadaptergraphic.h"

//#include "tfxserverdef.h"

//#include "subwocon.h"

#include <gfxtranseffect/gfxtranseffect.h>

#include <alfdecoderserverclient.h>

#include <alf/AlfTransEffectPlugin.h>

#include <alflogger.h>

//maximum number of ongoing component effects

//No restrictions at the moment. Anything goes.

//const TInt KMaxOngoing = 10;

enum TNoteSequenceState

    {

    ENoSequence = 0,

    EFirst = 1,

    EMid = 2,

    ELast = 3

    };

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

NONSHARABLE_CLASS(CTransControlDrawerInfo) : public CBase

	{

	CTransControlDrawerInfo(TInt aHandle);

public:

	static CTransControlDrawerInfo* NewL(TInt aHandle, TRect& aRect);

	~CTransControlDrawerInfo();

	inline TInt Handle();

	inline CWsTransControlGraphic* Drawer();

	void DeleteDrawer();

	void SetHasWOParticipants(TBool aHasWOParticipant);

	TBool HasWOParticipants();

private:

	TInt iHandle;

	TBool iHasWOParticipant;

//	CWsTransControlGraphic* iDrawer;

	};

CTransControlDrawerInfo::CTransControlDrawerInfo(TInt aHandle) :

	iHandle(aHandle)

	{

	}

CTransControlDrawerInfo* CTransControlDrawerInfo::NewL(TInt aHandle, TRect& /*aRect*/)

	{

	RThread t; //To get id of current thread to use as client handle.

	CTransControlDrawerInfo* self = new (ELeave) CTransControlDrawerInfo(aHandle);

	CleanupStack::PushL(self);

//	self->iDrawer = CWsTransControlGraphic::NewL(aRect, aHandle, t.Id());

	CleanupStack::Pop(self);

	return self;

	}

void CTransControlDrawerInfo::SetHasWOParticipants(TBool aHasWOParticipant)

	{

	iHasWOParticipant = aHasWOParticipant;

	}

TBool CTransControlDrawerInfo::HasWOParticipants()

	{

	return iHasWOParticipant;

	}

CTransControlDrawerInfo::~CTransControlDrawerInfo()

	{

//	delete iDrawer;

	}

void CTransControlDrawerInfo::DeleteDrawer()

	{

//	delete iDrawer;

//	iDrawer = NULL;

	}

//Inline functions kept here, since they are only used within this file

inline TInt CTransControlDrawerInfo::Handle()

	{

	return iHandle;

	}

/*

inline CWsTransControlGraphic* CTransControlDrawerInfo::Drawer()

	{

	return iDrawer;

	}

*/	

/**

 * Helper class, handles requests to the transition plugin

 */

NONSHARABLE_CLASS(CAlfTransitionRequest): public CActive

{

public:

	enum TType 

		{

		ETransFinish,

		EPolicyUpdate

		};

	CAlfTransitionRequest(CGfxTransAdapterTfx* aParent, MTfxServerObserver* aOwner, TType aType);

	~CAlfTransitionRequest();		

	void IssueReq();

	inline TType Type();

	TPtr8** InBuf() { return &iInPtr; }

	TPtr8** OutBuf() { return &iOutPtr; }

	void ResetBufs()

		{

		delete iInPtr;

    	iInPtr = 0;

		delete iOutPtr;

    	iOutPtr = 0;	

		}

private:

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

	MTfxServerObserver* iOwner;

	CGfxTransAdapterTfx* iParent;

	TType iType;

	TPtr8* iInPtr;

	TPtr8* iOutPtr;

};

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

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

//

CAlfTransitionRequest::CAlfTransitionRequest(CGfxTransAdapterTfx* aParent, MTfxServerObserver* aOwner, TType aType) : 

	CActive(CActive::EPriorityHigh), 

	iOwner(aOwner),

	iParent(aParent),

	iType(aType)

	{

	CActiveScheduler::Add(this);

	}

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

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

//

CAlfTransitionRequest::~CAlfTransitionRequest() 

	{

  	__ALFFXLOGSTRING("CAlfTransitionRequest - cancelling and deleting policy request" );

	Cancel();

	ResetBufs();

	}

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

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

//

void CAlfTransitionRequest::RunL()

	{

	ResetBufs();

	if ( iStatus.Int() == KErrCancel )

	    {

	    // If the request was cancelled, we are done

    	__ALFFXLOGSTRING("CAlfTransitionRequest: Policy request cancelled" );

	    return;

	    }

	switch( iType ) 

		{

/*		

// not supported at the time being - all transaction finishing is handled in alf

		case ETransFinish:

			iOwner->TransitionFinished(iStatus.Int());

			__ALFFXLOGSTRING1("Client::CActive.iOwner->TransitionFinished status = %d", iStatus.Int());

			break;

*/			

		case EPolicyUpdate:

			{

#ifdef _DEBUG

			RThread me;

			TInt ap = me.Id();

			me.Close();

			__ALFFXLOGSTRING2("CAlfTransitionRequest: Policy received. Cli: %d, status %d",ap,iStatus.Int());

#endif

            User::LeaveIfError( iStatus.Int() );

            iParent->GetNewPoliciesL( iStatus.Int() );

            User::LeaveIfError( iParent->RequestPolicyUpdates() );

			}

			break;

		default:

			break;

		}

	}

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

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

//

TInt CAlfTransitionRequest::RunError(TInt aError)

	{

	//The idea here is that on failure (wich should be OOM), we clear all our policies

	//clientside.

	//We must also inform server of this, so it can resend all policies the next time we request.

	//Next time a transition is tried, policies will be re-requested.

#ifdef _DEBUG

	RThread me;

	TInt meid = me.Id();

	TInt tmp = aError; //remove warning when debug prints and turned off

	aError = tmp;

	__ALFFXLOGSTRING2("--->> Policy error <<--. Cli: %d, status: %d",meid,aError);

	me.Close();

#endif

	iOwner->ClearAllPolicies(); //clear all policies clientside

	iParent->CancelPolicyUpdates(); //cancel requests on server.

	return 0;

	}

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

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

//

void CAlfTransitionRequest::DoCancel()

	{

    //nothing to do here. requests are cancelled elsewhere.

	}

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

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

//

void CAlfTransitionRequest::IssueReq() 

	{

	SetActive();

	}

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

// We keep it here, even though its inline, since it is never used outside this

// file anyway.

// The idea with .inl files is to keep the header file clean.

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

//

inline CAlfTransitionRequest::TType CAlfTransitionRequest::Type()

	{

	return iType;

	}

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

CGfxTransAdapterTfx::CGfxTransAdapterTfx(MGfxTransClient* aClient) :

	iClient(aClient),

	iConnected(EFalse),

	iHasPlugin(EFalse)

	{

	}

CGfxTransAdapterTfx::~CGfxTransAdapterTfx()

	{

    iControlEffects.Close();

	__ALFFXLOGSTRING("CGfxTransAdapterTfx for HWA transitionn effects, destructor ");

//	iIgnoredWOChildControls.Close();

	//iControlInfo.ResetAndDestroy();

	if ( iConnected )

	    {

	    if ( iHasPlugin )

	        {

        	__ALFFXLOGSTRING("CGfxTransAdapterTfx, canceling policy updates in destructor  ");

	        CancelPolicyUpdates();

	        // should we wait here until the cancellation has returned?

        	__ALFFXLOGSTRING("CGfxTransAdapterTfx, unloading plugin  ");

	        iTfxServer.UnloadTfxPlugin( iPluginImplementation );

	        }

	    }

	delete iPolicyReq;    

  	iTfxServer.Close();

  	iConnected = EFalse;

  	iHasPlugin = EFalse;

	delete iTransferBuffer;

	delete iReturnBuffer;

	delete iAsyncTransferBuffer;

	delete iAsyncReturnBuffer;

	}

void CGfxTransAdapterTfx::ConstructL()

	{

	__ALFFXLOGSTRING("CGfxTransAdapterTfx for HWA transitionn effects, ConstructL");

	RThread me;

	iClientId = me.Id();	

    me.Close();

    iPluginImplementation = TUid::Null();

    ConnectToServer();

    // We need to save various 32 bit integers. The exact number depends on the function.

    // We reserve a bit extra here, should check if the size is big enough for all cases.

    iTransferBuffer = HBufC8::NewL( 25 * sizeof(TInt32) );

    // If we get return values, we'll need a bigger buffer

    iReturnBuffer = HBufC8::NewL( sizeof( TInt ) );

    // We need to save various 32 bit integers. The exact number depends on the function.

    // We reserve a bit extra here, should check if the size is big enough for all cases.

    iAsyncTransferBuffer = HBufC8::NewL( 25 * sizeof(TInt32) );

    // If we get return values, we'll need a bigger buffer

    iAsyncReturnBuffer = HBufC8::NewL( sizeof( TInt ) );

	iPolicyReq = new( ELeave )CAlfTransitionRequest(this,

        this,

		CAlfTransitionRequest::EPolicyUpdate);

	}

void CGfxTransAdapterTfx::ConnectToServer()

    {

    // We need to resolve the plugin id for starters, 

    // use default parameters, we take the first one we find.

    TInt err = KErrNone;

    if ( !iConnected )

        {

        err = iTfxServer.Open();

        if ( err == KErrNone )

            {

            iConnected = ETrue;

            }

        else

            {

            // could not connect to server - cannot continue.

            return;

            }

        }

    if ( iHasPlugin )

        {

        // already connected

        return;

        }

    if ( iPluginImplementation == TUid::Null())

        {

        RImplInfoPtrArray pluginArray;

        TRAP( err, REComSession::ListImplementationsL( KAlfGfxPluginInterfaceUId, pluginArray ) );

	    if ( pluginArray.Count() > 0 )

	        {

	        iPluginImplementation = pluginArray[0]->ImplementationUid();

	        }

        // Clear the data in plugin array, it is not going to be used any more.    

        TInt i = 0;    

        for ( i = pluginArray.Count() - 1; i >= 0; i-- )

            {

            // destroy 

            delete pluginArray[i];

            pluginArray.Remove( i );

            }

        pluginArray.Close();

        }

    if ( err == KErrNone && iPluginImplementation != TUid::Null() )

        {

        err = iTfxServer.LoadTfxPlugin( iPluginImplementation );

        if ( err == KErrNone || err == KErrAlreadyExists )

            {

            // We have successfully loaded the plugin and saved

            // the implementation uid to be used later.

            iHasPlugin = ETrue;

        	__ALFFXLOGSTRING("HWA TransEffect Plugin loaded");

            }

        }

    }

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

// tests if adapter is active (trying to make it active if needed)

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

//

TBool CGfxTransAdapterTfx::IsActive()

	{

	TInt ap = iClientId.Id();

	__ALFFXLOGSTRING1("IsActive() cli: %d",ap);

	TInt err = KErrNone;

	if( !iHasPlugin ) 

		{

		ConnectToServer();

		if (!iHasPlugin )

		    {

    		return EFalse;

		    }

		}

	if( err == KErrNone )

		{

		//Make sure policy request handling is on.

		err = RequestPolicyUpdates();

		}

	else

		{

		//Failed to connect, remove all policies from client.

		iClient->ClearAllPolicies();

		}

	return (err == KErrNone);

	}

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

// Handles the different states of the client.

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

//

TInt CGfxTransAdapterTfx::HandleClientState( TClientState aState, const CCoeControl* aKey, TInt aHandle )

	{

	if( !iHasPlugin )

	    {

	    return KErrNone;

	    }

	TInt err = KErrNone;    

	const CTransitionData* transdata;

	err = iClient->GetTransitionData( aHandle, transdata );

	switch(aState)

		{

		case EFallback:

	    case EAbort:

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

	            {

	            // clear ongoing effect for this handle

	            if( iControlEffects[i].iHandle == aHandle)

	                {

	                iControlEffects.Remove(i);

	                i--;

	                }

	            }

		    break;

		case EPreBeginCapture:

		    break;

		case EPostBeginCapture:

			// Send control effect request to ALf. This is done immediately after call of 

			// GfxTransEffect::Begin(). This makes it possible (NOT QUARANTEENED)

			// that effect request arrives to Alf before possible visiblity changes are made to 

			// the control.

		    if (aKey && aKey->DrawableWindow() && err == KErrNone)

		        {

                TControlEffect newEffect;

                newEffect.iHandle = aHandle;

                newEffect.iWindowGroup = aKey->DrawableWindow()->WindowGroupId();

                newEffect.iWindowHandle =aKey->DrawableWindow()->ClientHandle(); 

                iControlEffects.Append(newEffect);

		        }

		    break;

		case EPreEndCapture:	

		    break;

		case EPostEndCapture:

            if (aKey && err == KErrNone)

                {

                TRAP( err, GenerateComponentTransitionEventL( transdata, MAlfGfxEffectPlugin::EBeginComponentTransition, aHandle ) );

                }

		    break;

		case EGlobalAbort:

		    // abort component transition, no handle.

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

                {

                // clear all on going effects

                iControlEffects.Remove(i);

                i--;

                }

          // TODO: send abort to server

		   // TRAP( err, GenerateComponentTransitionEventL( transdata, MAlfGfxEffectPlugin::EAbortComponentTransition) );

	        break;

		case EBeginGroup:

			{

            __ALFFXLOGSTRING1("-- BeginGroup: New transition group for groupid: %d)",aHandle);

            SendGroupCommand(aHandle, EFalse);

		    break;

			}

		case EEndGroup:

			{

            __ALFFXLOGSTRING1("-- EndGroup: closing transition group: %d)",aHandle);

            SendGroupCommand(aHandle, ETrue);