/*

* 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:   controls the calls that comes to the wsserverplugin by the use

*				 of a state machine

*

*/

#include "wsserverdrawercontroller.h"

#include "alfdrawerengine.h"

#include <akntranseffect.h> // for Transition effect enumerations

#include <e32property.h>

#include <UikonInternalPSKeys.h>

#include <ScreensaverInternalPSKeys.h>

#include <startupdomainpskeys.h>

#include <alflogger.h>

#include <coemain.h>

#include <bautils.h>

//#include <winchangecrp.h>

#ifdef WSSERVERDRAWER_TIME_LOG

_LIT(KWsServerDrawerTimeLogFile, "WsServerDrawerTimeLog.txt");

_LIT(KWsServerDrawerTimeLogDir, "alfgfxtest");

#endif //WSSERVERDRAWER_TIME_LOG

const TInt KEndCheckTime(500000); //half second

const TInt KEndTimeOut(10);  // 10 * KEndCheckTime

// We use a huge timeout for tests as it seems we hit the timeout way too often

//const TInt KEndCheckTime(1000000); //1 second

//const TInt KEndTimeOut(10);  // 10 * KEndCheckTime

/////////////////////////////////////////////////////////////////////////////////////////

/** These apps will never get fullscreen effects to or from them */

const TUint KNoEffectApps[] = 

		{

		0x100059B5,	//	S60 autolock

		0x10207218, //	akncapserver

//		0x100058B3, // 	phone app

		0x10281EF2, //  AknNotifyServer

//		0x100056CF, //	screensaver

		0x10210CB5, // 	MIDP, JavaLauncherExe

		0x1000594D, // IRApp, disables effect when activating IR

		0x102818E7,	// VCommandManager, start in device startup

		0x100058F3, // sys app

		0x102823b5, // SendUiServiceResolver,

		0x101F8681, // VideoTelUi

		0x101F875A, // KSWInstSvrUid, prevent fullscreen effect on installing

		0x101F8543, // Voice Commands, no effects when pressing send key long

		0x10281855  // touch input server , no effects when the first time start up

		// startup blocked because startup exit leaves the screen black.

		// must be debugged

        , 0x100058F4 // startup blocked for the time being

        // Application shell is Ok, folder open and close have KAknApplicationShellViewId

        // as both to and from ids. There is only one visual, so some sort of blur effect works...

		//, KAknApplicationShellViewId

		};		

/** Switching between theese app pairs will also never get effects */

const TUint KNoEffectPairs[][2] =

    {

    {0x0, 0x0},

    };

/** switch to/from these applications will never get any effects and

    the current ongoing effect will be aborted */

const TUint KCustomNoEffectApps[] = 

    {

	0x0, // DO NOT REMOVE 0x0! this is here for compile reasons, it will not be included in the AllowedCustomUid check

  //0xUID //Add UIds of applications that shouldn't have effects here

	};

// DISABLED! uncomment code in ConstructL that references this list to turn it on.

/** Switching between from or to theese apps should have always effects */

/*const TUint KExceptionEffectApps[] = 

	{

	0x100056CF, //	screensaver

	};

*/

/**

  *  Local funtion that checks if the uid is in the KCustomNoEffectApps list

*/

LOCAL_C TBool AllowedCustomUid(const TUid& aUid)

	{

	for(TInt i = 1; i < sizeof(KCustomNoEffectApps) / sizeof(KCustomNoEffectApps[0]); i++)

		{

		if(aUid.iUid == KCustomNoEffectApps[i])

			return EFalse;

		}

	return ETrue;

	}

/////////////////////////////////////////////////////////////////////////////////////////

class CPSListener : public CActive

    {

    public:

        inline TInt Value() const;

        inline TInt Key() const;

        CPSListener();

        void ListenL(const TUid& aUid, TInt aKey);

        ~CPSListener();

    private:

        void DoCancel();

        void RunL();

    private:

        RProperty iProperty;

        TInt iValue;

        TInt iKey;

    };

inline TInt CPSListener::Value() const

    {

    return iValue;

    }

inline TInt CPSListener::Key() const

    {

    return iKey;

    } 

CPSListener::CPSListener() : CActive(CActive::EPriorityHigh)

    {

    CActiveScheduler::Add(this);

    }

void CPSListener::ListenL(const TUid& aUid, TInt aKey)

    {

    Cancel();

    iKey = aKey;

    User::LeaveIfError(iProperty.Attach(aUid, aKey));

    RunL(); //set initial value

    }

CPSListener::~CPSListener()

    {

    Cancel();

    }

void CPSListener::DoCancel()

    {

    iProperty.Cancel();

    }

void CPSListener::RunL()    

    {

    iProperty.Subscribe(iStatus);

    iProperty.Get(iValue); //errors are ignored!

    SetActive();

    }

////////////////////////////////////////////////////////////////////////////////////////

CEndCheck* CEndCheck::NewL(MEndChecker& aCallBack)

	{

	CEndCheck* c = new (ELeave) CEndCheck(aCallBack);

	CleanupStack::PushL(c);

	c->ConstructL();

	CleanupStack::Pop();

	return c;

	}

void CEndCheck::Start(/*TInt aState,*/ TInt aMul)

	{

	Cancel();

	iCancelled = EFalse;

	After(KEndCheckTime * aMul);

	}

CEndCheck::~CEndCheck()

	{

	Cancel();

	}

void CEndCheck::DoCancel()

	{

	CTimer::DoCancel();

	iCancelled = ETrue;

	}

void CEndCheck::RunL()

	{

	if(!iCancelled)

		{

		iCallBack.EndExpired();

		}

	}

CEndCheck::CEndCheck(MEndChecker& aCallBack) : CTimer(CActive::EPriorityStandard), 

iCallBack(aCallBack)	

	{

	CActiveScheduler::Add(this);

	}

//////////////////////////////////////////////////////////////////////////////////////////

LOCAL_C void GetName(RFs& aFs, TDes& aName)

	{

	aFs.PrivatePath(aName);

	aName.Insert(0, _L("D:"));

	aName.Append(_L("data.bin"));	

	}

void CAppInfoCache::ReadArrayL(RFile& aFile) 

	{

	TPckgBuf<TUint> buf;

	User::LeaveIfError(aFile.Read(buf));

	const TUint count = buf();

	for(TUint i = 0; i < count; i++)

		{

		User::LeaveIfError(aFile.Read(buf));

		const TUint value = buf();

		User::LeaveIfError(aFile.Read(buf));

		const TUint flags = buf();

		User::LeaveIfError(aFile.Read(buf));

		const TUint aToUid = buf();

		User::LeaveIfError(aFile.Read(buf));

		const TUint root = buf();

		if(KErrNone == Append(value)) //dont allow duplicates

			{

			const TInt index = IndexOf(value);

			iAppInfo[index].iFlags = static_cast<TAppInfo::TFlags>(flags);

			iAppInfo[index].iParent = TUid::Uid(aToUid);

			iAppInfo[index].iRootWgId = static_cast<TInt>(root);

			}

		}

	}

void CAppInfoCache::WriteArrayL(RFile& aFile) const

	{

	const TUint count = static_cast<TUint>(iAppInfo.Count());

	User::LeaveIfError(aFile.Write(TPckgC<TUint>(count)));

	for(TUint i  = 0; i < count; i++)

		{

		const TAppInfo& info = iAppInfo[i];

		User::LeaveIfError(aFile.Write(TPckgC<TUint>(info.iUid)));

		User::LeaveIfError(aFile.Write(TPckgC<TUint>(info.iFlags)));

		User::LeaveIfError(aFile.Write(TPckgC<TUint>(info.iParent.iUid)));

		User::LeaveIfError(aFile.Write(TPckgC<TUint>(info.iRootWgId)));

		}

	}

TInt CAppInfoCache::TAppInfo::Order(const TAppInfo& aNodeA, const TAppInfo& aNodeB)

	{

	if(aNodeA.iUid < aNodeB.iUid)

		return 1;

	if(aNodeA.iUid > aNodeB.iUid)

		return -1;

	return 0;

	}

TInt CAppInfoCache::Append(TUint aUid)

	{

	return iAppInfo.InsertInOrder(TAppInfo(aUid), TLinearOrder<TAppInfo>(TAppInfo::Order));

	}

TInt CAppInfoCache::IndexOf(TUint aUid) const

	{

	return iAppInfo.FindInOrder(TAppInfo(aUid), TLinearOrder<TAppInfo>(TAppInfo::Order));

	}

CAppInfoCache* CAppInfoCache::NewL()

	{

	CAppInfoCache* f = new (ELeave) CAppInfoCache();

	CleanupStack::PushL(f);

	f->ConstructL();

	CleanupStack::Pop();

	return f;

	}

CAppInfoCache::~CAppInfoCache()

	{

	TRAP_IGNORE(ExportL());

	iLs.Close();

	iAppInfo.Close();

	}

void CAppInfoCache::ConstructL()

	{	

	ImportL();

	User::LeaveIfError(iLs.Connect());	

	}

TBool CAppInfoCache::GateFound() const

	{

	return ETrue;

	}

void CAppInfoCache::ExportL()

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	TFileName name;

	GetName(fs, name);

	BaflUtils::EnsurePathExistsL(fs, name);

	RFile file;

	User::LeaveIfError(file.Replace(fs, name, EFileWrite));

	CleanupClosePushL(file);

	User::LeaveIfError(file.Write(TPckgC<TUint>(iFocusedUid.iUid)));

	WriteArrayL(file);

	CleanupStack::PopAndDestroy(2); //file, fs

	}

void CAppInfoCache::ImportL()

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	TFileName name;

	GetName(fs, name);

	RFile file;

	const TInt err = file.Open(fs, name, EFileRead);

	if(err == KErrNone)

		{

		TPckgBuf<TUint> buf;

		User::LeaveIfError(file.Read(buf));

		iFocusedUid = TUid::Uid(buf());

		CleanupClosePushL(file);

		ReadArrayL(file);

		CleanupStack::PopAndDestroy(); //file

		fs.Delete(name); //free up memory after import

		}

	CleanupStack::PopAndDestroy(); //fs

	}

TInt CAppInfoCache::SetUid(const TUid& aUid)

	{

	if(aUid == KNullUid)

		return KErrNone;

	TInt err = Append(aUid.iUid);

	if( err == KErrAlreadyExists )

	    {

	    err = KErrNone;

	    }

	return err;

	}

void  CAppInfoCache::SetAppFlags(const TUid& aUid, TUint aFlag, TBool aSet)

	{

	const TInt index = IndexOf(aUid.iUid);

	if(index >= 0)

		{

		if(aSet)

			iAppInfo[index].iFlags |= aFlag;

		else

			iAppInfo[index].iFlags &= ~aFlag;

		}	

	}

TBool CAppInfoCache::GetAppFlags(const TUid& aUid, TUint aFlag) const

 	{

 	return TBool(iAppInfo[IndexOf(aUid.iUid)].iFlags & aFlag);

 	}

void CAppInfoCache::SetAvkonUid(const TUid& aUid)

	{	

  	SetAppFlags(aUid, TAppInfo::EAvkonApp, ETrue);

	}

void CAppInfoCache::RemoveAvkonUid(const TUid& aUid)

	{

	SetAppFlags(aUid, TAppInfo::EAvkonApp, EFalse);

	}

TBool CAppInfoCache::AvkonUid(const TUid& aUid) const

	{

	TInt index = IndexOf(aUid.iUid);

	if (index!=KErrNotFound)

	    {

	    return (iAppInfo[index].iFlags & TAppInfo::EAvkonApp);

	    }

	else

	    {

	    return EFalse;

	    }

	}

void CAppInfoCache::Reset(const TUid& aUid)

	{

 	SetParent(aUid, KNullUid);

	}

void CAppInfoCache::SetParent(const TUid& aUid, const TUid& aParentUid)

	{

	iAppInfo[IndexOf(aUid.iUid)].iParent = aParentUid;

	}

TInt CAppInfoCache::SetAction(const TUid& aUid, TInt aAction)

    {

    if (aAction==AknTransEffect::ENone || aUid == KNullUid)

        {

        // previous action is more valid than this

        return aAction;

        }

    TInt index = IndexOf(aUid.iUid);

    if (index == KErrNotFound)

        {

        SetUid(aUid);

        index = IndexOf(aUid.iUid);

        if(index == KErrNotFound)

            {

            __ALFFXLOGSTRING1("CAppInfoCache::SetAction - Could not add Uid 0x%x to AppInfoCache!", aUid.iUid);

            return aAction;

			}

        }

        switch(iAppInfo[index].iAction)

            {

            case AknTransEffect::EAppStartupBackground:

                if (aAction == AknTransEffect::EApplicationExit)

                    {

                    aAction = AknTransEffect::EEmbeddedApplicationExit; 

                    }

                break;

            case AknTransEffect::EApplicationStartRect:

            case AknTransEffect::EApplicationStartSwitch:

            case AknTransEffect::EApplicationStartSwitchRect:

                {

                // these cannot be overwritten

                if (aAction!=KErrNotFound) // resetting the state is allowed regardless of earlier state

                    {

                    return iAppInfo[index].iAction;

                    }

                break;

                }

            }

        iAppInfo[index].iAction = aAction;

        RDebug::Printf("CAppInfoCache::SetAction - Returned action %d", iAppInfo[index].iAction);

        return iAppInfo[index].iAction;

    }

TInt CAppInfoCache::Action(const TUid& aUid)

    {

    TInt index = IndexOf(aUid.iUid);

    if (index != KErrNotFound)

        {

        return iAppInfo[index].iAction;

        }

    return KErrNotFound;

    }

TBool CAppInfoCache::IsEmbedded(const TUid& aUid) const		

	{

	return iAppInfo[IndexOf(aUid.iUid)].iParent != KNullUid;

	}

TBool CAppInfoCache::IsSameParent(const TUid& aUid1, const TUid& aUid2) const

	{

	if(aUid1 == KNullUid || aUid2 == KNullUid)

		return EFalse;

	TAppInfo appInfo = iAppInfo[IndexOf(aUid1.iUid)];

	appInfo.iParent.iUid = (appInfo.iParent == KNullUid) ? appInfo.iUid : appInfo.iParent.iUid;

	TAppInfo parentAppInfo = iAppInfo[IndexOf(aUid2.iUid)];

	parentAppInfo.iParent.iUid = (parentAppInfo.iParent == KNullUid) ? parentAppInfo.iUid : parentAppInfo.iParent.iUid;

	if(appInfo.iParent == parentAppInfo.iParent) // Same root?

		return ETrue;

	return EFalse;

	}	

const TUid& CAppInfoCache::FocusUid() const

	{

	return iFocusedUid;

	}

TBool CAppInfoCache::SetFocusUid(TInt aWgId)

	{

    if (aWgId)

    	{

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

			{

			if(iAppInfo[i].iRootWgId == aWgId)

				{

				iFocusedUid = TUid::Uid(iAppInfo[i].iUid);

				return ETrue;

				}

			}

		}

	return EFalse;

	}

void CAppInfoCache::ClearActions()

    {