/*

* Copyright (c) 2002-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:  Server side implementation of AVKON System

*                Graphics Coordinator.

*

*/

#include "AknEikSgcs.h"

#include <eikenv.h>

#include "eiksrvsp.h"

#include <AknSgcc.h>

#include <aknenv.h>

#include <AknDef.h>

#include <aknappui.h>

#include <e32property.h>

#include <UikonInternalPSKeys.h>

#include <avkondomainpskeys.h>

#include <AknSettingCache.h>

#include "AknCapServerEntry.h"

#include <aknconsts.h>

#include "winchangemonitor.h"

#include "akncapserverdebug.h"

#include "akncompaif.h"

#include <AknsConstants.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "avkoninternalpskeys.h"

#include <layoutmetadata.cdl.h>

#include <AknTaskList.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LAYOUT_SWITCH

#include <akntranseffect.h>

#include <akntransitionutils.h>

#endif

#include <LayoutPack.cdl.h>

#include <CdlRefs.h>

const TInt KCdlEComInterfaceId = 0x101f8243;

const TInt KLayoutChangeTimeout = 2000000; // 2s

const TInt KWgStatesGranularity = 4;

const TInt KRelinquishedThreadListGranularity = 4;

const TInt KRemoveBlankDelay = 200000; // 0.2s

// Drawing is slower when transparency is enabled. The time needs to be

// big enough to account for slowest drawing application.

const TInt KRemoveBlankDelayTransparency = 1500000; // 1.5s

// 4s should be enough for foreground app's operations to complete.

const TInt KRestoreThreadPriorityDelay = 4000000; 

// Screensaver application UID

const TUid KScreensaverAppUid = { 0x100056CF };

// Read pass policy

_LIT_SECURITY_POLICY_PASS(KPassReadPolicy);    

// Policy requiring write device data capability.

_LIT_SECURITY_POLICY_C1(KWriteDDPolicy, ECapabilityWriteDeviceData);

enum TWgStateFlags

    {

    EWgStateFullScreen,

    EWgStatePartialForeground,

    EWgStateUnderstandsPartialForeground,

    EWgStateLegacyLayout,

    EWgStateOrientationSpecified,

    EWgStateOrientationLandscape

    };

enum TSetLayoutBlankStep

	{

	ESetLayoutBlankBeforeLayoutLoad,

	ESetLayoutBlankBetweenLayoutLoadAndScreenRotate,

	ESetLayoutBlankAfterScreenRotate,

	ESetLayoutBlankNever

	};

NONSHARABLE_CLASS(CAknSgcServerImpl) : public CAknSgcImpl

	{

public:

	CAknSgcServerImpl(CEikSgcServer* aServer);

    void MoveApp(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere);

private:

	CEikSgcServer* iServer;

	};

class CLayoutChangeCallBack : public CActive

    {

public:

    CLayoutChangeCallBack(CEikSgcServer* aSgc);

    void ConstructL();

    ~CLayoutChangeCallBack();

    void RestartTimerL();

private:

    void DoCancel();

    void RunL();

    static TInt ThreadFunc(TAny* aStat);

    static TInt TimeoutCallback(TAny* aThis);

    void DoTimeout();

private:

    CEikSgcServer* iSgc;

    RThread iThread;

    TThreadId iMain;

    CPeriodic* iTimeout;

    };

CLayoutChangeCallBack::CLayoutChangeCallBack(CEikSgcServer* aSgc)

: CActive(CActive::EPriorityLow), iSgc(aSgc), iMain(RThread().Id())

    {

    CActiveScheduler::Add(this);

    }

void CLayoutChangeCallBack::ConstructL()

    {

    // Create the thread.

    User::LeaveIfError(iThread.Create(KNullDesC, ThreadFunc, 0x400, NULL, this));

    iThread.SetPriority(EPriorityAbsoluteBackground);

    // Set the active status & start the thread.

    iStatus = KRequestPending;

    SetActive();

    iThread.Resume();

    RestartTimerL();

    }

void CLayoutChangeCallBack::RestartTimerL()

    {

    delete iTimeout;

    iTimeout = NULL;

    iTimeout = CPeriodic::NewL(CActive::EPriorityStandard);

    iTimeout->Start(KLayoutChangeTimeout, KLayoutChangeTimeout, TCallBack(TimeoutCallback, this));

    }

CLayoutChangeCallBack::~CLayoutChangeCallBack()

    {   

    Cancel();

    iThread.Close();

    delete iTimeout;

    }

void CLayoutChangeCallBack::DoCancel()

    {

    iThread.Terminate(0);

    // Only complete the request if not yet completed by the background thread.

    if ( iStatus == KRequestPending )

        {

        TRequestStatus* pStatus = &iStatus;

        User::RequestComplete(pStatus, KErrCancel);     

        }

    }

void CLayoutChangeCallBack::RunL()

    {

    iSgc->HandleLayoutChangeCallBackL();

    }

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

// CLayoutChangeCallBack::ThreadFunc

// Thread entry point function.

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

//

TInt CLayoutChangeCallBack::ThreadFunc( TAny* aLayoutChangeCallBack )

    {

    CLayoutChangeCallBack* self =

        static_cast<CLayoutChangeCallBack*>(aLayoutChangeCallBack);

    RThread main;

    if (KErrNone == main.Open(self->iMain))

        {

        TRequestStatus* pStatus = &self->iStatus;

        main.RequestComplete(pStatus, KErrNone);

        main.Close();

        }

    return KErrNone;

    }

TInt CLayoutChangeCallBack::TimeoutCallback( TAny* aThis )

    {

    static_cast<CLayoutChangeCallBack*>( aThis )->DoTimeout();

    return EFalse;

    }

void CLayoutChangeCallBack::DoTimeout()

    {

    TRAP_IGNORE( iSgc->HandleLayoutChangeCallBackL() );

    }

CEikSgcServer::TWgState::TWgState()

: iWgId(0), iSpLayout(0), iSpFlags(0), iAppScreenMode(KAknScreenModeUnset)

    {

    // Default state for window groups is full screen - handles non

    // avkon apps.

    iFlags.Set(EWgStateFullScreen);

    }

CEikSgcServer::TWgState::TWgState(TInt aWgId)

: iWgId(aWgId), iSpLayout(0), iSpFlags(0), iAppScreenMode(KAknScreenModeUnset)

    {

    // Default state for window groups is full screen - handles non

    // avkon apps.

    iFlags.Set(EWgStateFullScreen);

    }

inline TInt CEikSgcServer::TWgState::WgId() const

    {

    return iWgId;

    }

inline void CEikSgcServer::TWgState::SetWgId(TInt aWgId)

    {

    iWgId = aWgId;

    }

inline TInt CEikSgcServer::TWgState::SpLayout() const

    {

    return iSpLayout;

    }

inline void CEikSgcServer::TWgState::SetSpLayout(TInt aSpLayout)

    {

    iSpLayout = aSpLayout;

    }

inline TInt CEikSgcServer::TWgState::SpFlags() const

    {

    return iSpFlags;

    }

inline void CEikSgcServer::TWgState::SetSpFlags(TInt aSpFlags)

    {

    iSpFlags = aSpFlags;

    }

inline TBool CEikSgcServer::TWgState::IsFullScreen() const

    {

    return iFlags[EWgStateFullScreen];

    }

inline void CEikSgcServer::TWgState::SetFullScreen(TBool aFullScreen)

    {

    iFlags.Assign(EWgStateFullScreen, aFullScreen);

    }

inline TBool CEikSgcServer::TWgState::IsPartialForeground() const

    {

    return iFlags[EWgStatePartialForeground];

    }

inline void CEikSgcServer::TWgState::SetPartialForeground(TBool aPartialForeground)

    {

    iFlags.Assign(EWgStatePartialForeground, aPartialForeground);

    }

inline TBool CEikSgcServer::TWgState::UnderstandsPartialForeground() const

    {

    return iFlags[EWgStateUnderstandsPartialForeground];

    }

inline void CEikSgcServer::TWgState::SetUnderstandsPartialForeground(TBool aPartialForeground)

    {

    iFlags.Assign(EWgStateUnderstandsPartialForeground, aPartialForeground);

    }

inline TBool CEikSgcServer::TWgState::IsLegacyLayout() const

    {

    return iFlags[EWgStateLegacyLayout];

    }

inline void CEikSgcServer::TWgState::SetLegacyLayout(TBool aLegacyLayout)

    {

    iFlags.Assign(EWgStateLegacyLayout, aLegacyLayout);

    }

inline TBool CEikSgcServer::TWgState::IsOrientationSpecified() const

    {

    return iFlags[EWgStateOrientationSpecified];

    }

inline void CEikSgcServer::TWgState::SetOrientationSpecified(TBool aOrientationSpecified)

    {

    iFlags.Assign(EWgStateOrientationSpecified, aOrientationSpecified);

    }

inline TBool CEikSgcServer::TWgState::IsOrientationLandscape() const

    {

    return iFlags[EWgStateOrientationLandscape];

    }

inline void CEikSgcServer::TWgState::SetOrientationLandscape(TBool aOrientationLandscape)

    {

    iFlags.Assign(EWgStateOrientationLandscape, aOrientationLandscape);

    }

inline TInt CEikSgcServer::TWgState::AppScreenMode() const

    {

    return iAppScreenMode;

    }

inline void CEikSgcServer::TWgState::SetAppScreenMode(TInt aAppScreenMode)

    {

    iAppScreenMode = aAppScreenMode;

    }

CEikSgcServer* CEikSgcServer::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CEikSgcServer::CEikSgcServer()

: iWs(CEikonEnv::Static()->WsSession()),

  iLastScreenModeSet(-1), 

  iRelinquishedThreads(KRelinquishedThreadListGranularity),

  iSetLayoutBlankStep(ESetLayoutBlankBeforeLayoutLoad)

    {

    }

void CEikSgcServer::ConstructL()

    {

    iWgStates = new(ELeave) CWgStates(KWgStatesGranularity);

    TInt err = RProperty::Define(KPSUidUikon, KUikPreferredOrientation, RProperty::EInt);

    User::LeaveIfError(err);

    err = RProperty::Define(

        KPSUidAvkonDomain, 

        KAknNotificationsInIdleAllowed, 

        RProperty::EInt,

        KPassReadPolicy,

        KWriteDDPolicy);

    User::LeaveIfError(err);

#if FADE_BITMAP

	err = RProperty::Define(KPSUidAvkonInternal, KAknFadeBitmapHandle,

							RProperty::EInt,

							KPassReadPolicy,

							KWriteDDPolicy);

	User::LeaveIfError(err);

	err = RProperty::Define(KPSUidAvkonInternal, KAknFadeMaskHandle,

							RProperty::EInt,

							KPassReadPolicy,

							KWriteDDPolicy);

	User::LeaveIfError(err);

#endif

	err = RProperty::Define(KPSUidAvkonInternal, KAknFadeColorHandle,

							RProperty::EInt,

							KPassReadPolicy,

							KWriteDDPolicy);

	User::LeaveIfError(err);

	err = RProperty::Define(KPSUidAvkonInternal, KAknFadeBlackMapHandle,

							RProperty::EInt,

							KPassReadPolicy,

							KWriteDDPolicy);

	User::LeaveIfError(err);

	err = RProperty::Define(KPSUidAvkonInternal, KAknFadeWhiteMapHandle,

							RProperty::EInt,

							KPassReadPolicy,

							KWriteDDPolicy);

	User::LeaveIfError(err);

#ifndef TFX_USE_WCHANGE_EVENT

    iWinChange = CWindowChangeMonitor::NewL(iWs);

#endif

	CAknSgcServerImpl* sgcImpl = new(ELeave) CAknSgcServerImpl(this);

	// CAknSgcClient takes ownership of sgcImpl and replaces

	// existing client impl with it.

	CAknSgcClient::SetImpl(sgcImpl);	

    // Touch compatibility mode

    iAvkonAppUiBase->MopGetObjectNoChaining(iTouchCompaModeIf);

    iTouchCompaScreenMode = KErrNotFound;

    if (iTouchCompaModeIf)

        {

        iTouchCompaScreenMode = iTouchCompaModeIf->FindCompaScreenMode();

        }

    // ECom notifier for ILD installations

	TCallBack callback(CEikSgcServer::LayoutInstallationCallBack, this);

	iLayoutNotifier = CEComPluginNotifier::NewL(KNullUid, callback);

	iLayoutNotifier->Start();

	EComPluginUtils::GetInfoArrayL(TUid::Uid(KCdlEComInterfaceId), iPrevPluginInfo);

    }

TInt CEikSgcServer::LayoutInstallationCallBack(TAny* aPtr)

	{

	return ((CEikSgcServer*)aPtr)->RefreshLayoutIfRequiredL();

	}

TInt CEikSgcServer::RefreshLayoutIfRequiredL()

	{

	REComPluginInfoArray newPlugins;

	EComPluginUtils::GetInfoArrayL(TUid::Uid(KCdlEComInterfaceId), newPlugins);

	REComPluginInfoArray newPluginsCopy = newPlugins;

	// Remove any plugins that haven't changed from the arrays

	TInt prevCount = iPrevPluginInfo.Count();

	while(prevCount > 0)

		{

		prevCount--;

		TUid prevUid = (iPrevPluginInfo[prevCount]).iUid;

		TInt prevVer = (iPrevPluginInfo[prevCount]).iVersion;

		TInt newCount = newPlugins.Count();

		while(newCount > 0)

			{

			newCount--;

			TUid newUid = (newPlugins[newCount]).iUid;

			TInt newVer = (newPlugins[newCount]).iVersion;

			if(prevUid == newUid && prevVer == newVer)

				{

				newPlugins.Remove(newCount);

				iPrevPluginInfo.Remove(prevCount);

				break;

				}

			}

		}

	TBool refreshRequired = EFalse;

	if(iPrevPluginInfo.Count() > 0)

		{

		// A plugin has been removed, but we can't check what it contained.

		refreshRequired = ETrue;

		}

	else

		{

		// Check through the changed plugins to see whether any contain layout packs

		_LIT(KLitDllPath, "%S%08x.dll");

		const TInt KPathLength = 14;	// Drive letter + ":" + UID + ".dll"

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

			{

			TEComPluginInfo imp = newPlugins[i];

			TBuf<KPathLength> buf;

			TDriveName drive(imp.iDrive.Name());

			buf.Format(KLitDllPath, &drive, imp.iUid.iUid);

			CCdlRefCollection* refsInFile = CdlEngine::FileContentsLC(buf);

			CCdlRefs* refs = CCdlRefs::NewLC();

			refs->AppendL(*refsInFile);

			CCdlRefs* layoutsInFile = refs->SubsetByUidLC(LayoutPack::KCdlInterfaceUid);

			TInt numLayouts = layoutsInFile->CountRefs();

			CleanupStack::PopAndDestroy(3, refsInFile);

			if(numLayouts > 0)

				{

				// Plugin added with layouts, refresh required

				refreshRequired = ETrue;

				break;

				}

			}

		}

	// Send the event if it's needed

	TInt result = KErrNone;

	if(refreshRequired)

		{

		RWsSession session;

		TInt err = session.Connect();

        if ( err == KErrNone )

            {

            TWsEvent event;

            event.SetType(KAknILDInstallationLayoutSwitch);

            result = session.SendEventToAllWindowGroups(event);

            session.Close();

            }

		}

	// Store the copy of the new list of plugins for next time

	iPrevPluginInfo.Reset();

	iPrevPluginInfo = newPluginsCopy;

	return result;

    }

CEikSgcServer::~CEikSgcServer()

    {

	delete iFadeBitmap;

	delete iFadeMask;

    delete iWinChange;

    delete iLayoutChangeCallBack;

    delete iWgStates;

    delete iRemoveBlankCallBack;

    delete iLayoutNotifier;

    }

void CEikSgcServer::HandleWindowGroupListChangeL()

    {

    CWgIds* wgIds = CreateWgIdListLC();

    if (!TestWgListOrderOk(wgIds))

        {