// Copyright (c) 1995-2009 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:

// Window server 'server' class

// 

//

#include "server.h"

#include "panics.h"

#include "wstop.h"

#include "EVENT.H"

#include <bitdraw.h>

#include <hal.h>

#include "inifile.h"

#include "wspluginmanager.h"

#include "graphics/windowserverconstants.h"

GLREF_D CDebugLogBase *wsDebugLog;

const TUint KRangeCount = 1; 

// We use a lot of 64 bit time calculations, but a periodic can only cope with signed 32 bit times

// which gives them a limit of about 35 minutes.

// Fortunately, our animtions are safe if redrawn early.  Every half an hour isn't going to hurt.

const TTimeIntervalMicroSeconds KHalfHour = 30 * 60 * 1000 * 1000;

const TInt KWsServRanges[KRangeCount] = 

	{	

	0

	};

const TUint8 KElementsIndex[KRangeCount] =

	{

	CPolicyServer::EAlwaysPass,		

	};

const CPolicyServer::TPolicyElement KPolicyElements[] = 

	{ 

	{_INIT_SECURITY_POLICY_C1(ECapabilityPowerMgmt), CPolicyServer::EFailClient}, 

	{_INIT_SECURITY_POLICY_C1(ECapabilitySwEvent), CPolicyServer::EFailClient}, 

	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient} 

	};

const CPolicyServer::TPolicy KWsServPolicy =

	{

	CPolicyServer::EAlwaysPass, 

	KRangeCount,

	KWsServRanges,

	KElementsIndex,

	KPolicyElements 	

	};

// CWindowServer::CDefaultAnimationScheduler \\\\\\\\\\\\\\\\\\\\\\\\\\\

class CWindowServer::CDefaultAnimationScheduler: public CBase, public MWsAnimationScheduler

	{

	// Associates a screen number with a CActiveSchedulerWait intance. This is used to

	// achieve synchronous update completion on a specific screen.

	class CScreenUpdateWait : public CActiveSchedulerWait

		{

		public:

			CScreenUpdateWait(TInt aScreenNumber) : iScreenNumber (aScreenNumber) {}

			TInt iScreenNumber;	

		};

	struct TScreenUpdateDetails

		{

		CWindowServer::CDefaultAnimationScheduler* iScheduler;

		TInt  iScreenNumber;

		};

	struct TSchedule

		{

		MWsScreen* iScreen; // used as a unique index, searching with FindInUnsignedKeyOrder

		TInt  iScreenNumber;

		TBool iScheduled;

		TTime iWhen;

		TBool iRedraw;

		};

public:

	enum TInactivityBehaviour

		{

		EStopAnimation,

		EStopAllDrawing,

		EIgnore,

		};

	class CScreenState;

	CDefaultAnimationScheduler(MWsGraphicDrawerEnvironment& aEnv);

	~CDefaultAnimationScheduler();

	void ConstructL();		//LeaveScan:  member of nested class declaration

	// implementing MWsAnimationScheduler

	void ScheduleAnimation(MWsScreen& aScreen,const TTime& aWhen);

	void UnscheduleAnimation(MWsScreen& aScreen);

	void Invalidate(const TGraphicDrawerId& aId);

	void OnInactive();

	void OnActive();

	void ScheduleRedraw(MWsScreen& aScreen,const TTime& aWhen);

	void DoRedrawNow(MWsScreen& aScreen);

	void DoRedrawNow(MWsScreen& aScreen, MWsAnimationScheduler::MScreenUpdateObserver& aObserver);

	void ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver);

private:

	static TBool OnIdleCallBack(TAny* aAny);

	void ScheduleUpdate (TInt aScreenNumber, TBool aForce);

	void OnIdleCallBack(TBool aForce);

	static TBool InvokeDueAnimation(TAny* aAny);

	void RedrawAllInvalidatedRegions (TInt aScreen);

	TSchedule* GetScheduledScreenUpdate(TInt aScreen);

	void InvokeDueAnimation(TInt aScreen);

	void ProcessUpdateCompletion (TInt aScreenNumber);

	TInt ScreenNumber(MWsScreen& aScreen) const;

	TTimeIntervalMicroSeconds GetDueDelta (TBool aForceRedraw, TSchedule* aScheduledUpdate);

private:

	RPointerArray<CScreenUpdateWait> iRedrawWaitLoop; 

	RPointerArray<CScreenState> iScreenState;

	MWsGraphicDrawerEnvironment& iEnv;

	static const TInt64 KRedrawGrace;

	static const TInt64 KAnimationGrace;

	CAsyncCallBack* iIdleInitiator;

	TBool iInRedrawNow;

	RArray<TSchedule> iSchedule;

	TBool iInactive;

	TBool iInactiveDraws;

	TBool iRedrawScheduled;

	TInt64 iRedrawGracePeriod;

	TInt64 iAnimationGracePeriod;

	TInactivityBehaviour iInactivityBehaviour;

	};

class CWindowServer::CDefaultAnimationScheduler::CScreenState : public CActive

	{

public:

	static CScreenState* NewL (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal);

	~CScreenState();

	void SetActive ();

	void WaitForRedraws(MWsAnimationScheduler::MScreenUpdateObserver& aObserver, TInt aNumRedraws);

	void ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver);

	CPeriodic* iUpdateOn;

	TTime      iExpectedTickTime;

	TScreenUpdateDetails iScreenUpdateDetails;

	RArray<TGraphicDrawerId> iInvalidated;

	TBool 		iInvalidateAll;

private:

	CScreenState (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal);

	void ConstructL ();

	void ReleaseRemainingClients();

	void ReleaseClientsWaitingFor(TUint aCurrentFrame);

	void RunL();

	void DoCancel() 

		{

		TRequestStatus* tmpTRS = &iStatus;

		User::RequestComplete(tmpTRS, KErrNone);

		};

	class TWaitingClient

		{

	public:

		TWaitingClient(MWsAnimationScheduler::MScreenUpdateObserver& aObserver, TInt aTargetFrame)

			: iObserver(aObserver), iTargetFrame(aTargetFrame)

			{

			}

		MWsAnimationScheduler::MScreenUpdateObserver& iObserver;

		TUint iTargetFrame;

		};

	TUint iFrameCount;

	RArray<TWaitingClient> iWaitingClients;

	};

// If using the default animation scheduler on a device, these two numbers may be worth tweaking in the inifile

// However, both are maximum periods - wserv will go faster than either if nothing else is using the system.

const TInt64 CWindowServer::CDefaultAnimationScheduler::KRedrawGrace = 0; // do redraws immediately

const TInt64 CWindowServer::CDefaultAnimationScheduler::KAnimationGrace = 0; // do animation redraws immediately

CWindowServer::CDefaultAnimationScheduler::CDefaultAnimationScheduler(MWsGraphicDrawerEnvironment& aEnv):

	iEnv(aEnv), iSchedule(1,_FOFF(TSchedule,iScreen))

	{

	}

CWindowServer::CDefaultAnimationScheduler::~CDefaultAnimationScheduler()

	{

	iSchedule.Close();

	delete iIdleInitiator;

	TInt screenCount = iScreenState.Count();

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

		delete iScreenState[ii];

	iScreenState.Close();

	// Destroy the redraw wait loops associated each screen, and close

	// the associated Array objects.

	TInt waitLoopCount = iRedrawWaitLoop.Count();

	for (TInt waitLoop = 0; waitLoop < waitLoopCount; waitLoop++)

		delete iRedrawWaitLoop[waitLoop];

	iRedrawWaitLoop.Close();

	}

void CWindowServer::CDefaultAnimationScheduler::ConstructL()

	{

	_LIT(KOnInactive,"ONINACTIVE");

	_LIT(KStopAnimation,"STOPANIMATION");

	_LIT(KStopAllDrawing,"STOPALLDRAWING");

	_LIT(KIgnore,"IGNORE");

	TPtrC inactivityBehaviourString;

	WsIniFile->FindVar(KOnInactive,inactivityBehaviourString);

	if(inactivityBehaviourString.CompareF(KStopAnimation)==0)

		iInactivityBehaviour = EStopAnimation;

	else if(inactivityBehaviourString.CompareF(KStopAllDrawing)==0)

		iInactivityBehaviour = EStopAllDrawing;

	else if(inactivityBehaviourString.CompareF(KIgnore)==0)

		iInactivityBehaviour = EIgnore;

	_LIT(KRedrawGracePeriod, "REDRAWGRACEPERIOD");

	TInt tmp = KRedrawGrace;

	WsIniFile->FindVar(KRedrawGracePeriod, tmp);

	iRedrawGracePeriod = tmp;

	_LIT(KAnimationGracePeriod, "ANIMATIONGRACEPERIOD");

	tmp = KAnimationGrace;

	WsIniFile->FindVar(KAnimationGracePeriod, tmp);

	iAnimationGracePeriod = tmp;

	iIdleInitiator = new(ELeave) CAsyncCallBack(TCallBack(OnIdleCallBack,this),EWsGraphicAnimateAwaitIdlePriority);

	TInt screenCount;

	User::LeaveIfError(HAL::Get( HAL::EDisplayNumberOfScreens, screenCount)); 

	for (TInt i = 0; i < screenCount; i++)

		{

		CScreenState* screenState = CScreenState::NewL (this, i);

		CleanupStack::PushL(screenState);

		iScreenState.AppendL (screenState);

		CleanupStack::Pop(screenState);

		}

	// Ensure that the wait loop array has some allocated slots, making it highly 

	// unlikely that Append() will fail due to OOM.

	iRedrawWaitLoop.ReserveL (8);

	}

void CWindowServer::CDefaultAnimationScheduler::Invalidate(const TGraphicDrawerId& aId)

	{

	const TInt screenCount = iEnv.ScreenCount();

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

		{

		CScreenState* screenState = iScreenState[ii];

		if(!screenState->iInvalidateAll)

			{

			switch(screenState->iInvalidated.InsertInOrder(aId,TLinearOrder<TGraphicDrawerId>(TGraphicDrawerId::Compare)))

				{

				case KErrNone:

				case KErrAlreadyExists:

					break;

				default:

					screenState->iInvalidateAll = ETrue;

					screenState->iInvalidated.Reset();

				}

			}

		}

	iIdleInitiator->CallBack();

	}

CWindowServer::CDefaultAnimationScheduler::CScreenState::CScreenState (CDefaultAnimationScheduler* aScheduler, TInt aScreenNumber):

	CActive(EComposeCompletePriority)

	{

	iScreenUpdateDetails.iScheduler = aScheduler;

	iScreenUpdateDetails.iScreenNumber = aScreenNumber;

	}

CWindowServer::CDefaultAnimationScheduler::CScreenState* 

CWindowServer::CDefaultAnimationScheduler::CScreenState::NewL (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal)

	{

	CScreenState* self = new(ELeave)CScreenState(aScheduler, aScreenOrdinal);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;	

	}

void CWindowServer::CDefaultAnimationScheduler::CScreenState::ConstructL ()

	{

	iUpdateOn = CPeriodic::NewL(EComposeCompletePriority);

	iWaitingClients.ReserveL(8);

	CActiveScheduler::Add(this);

	}

CWindowServer::CDefaultAnimationScheduler::CScreenState::~CScreenState()

	{

	CActive::Cancel();

	iInvalidated.Close();

	delete iUpdateOn;

	TInt i = iWaitingClients.Count();

	while(i--)

		{

		iWaitingClients[i].iObserver.ScreenUpdateComplete(KErrAbort);

		}

	iWaitingClients.Close();

	}

void CWindowServer::CDefaultAnimationScheduler::CScreenState::SetActive()

	{

	CActive::SetActive ();

	}

/**

This function is called from CWsClient d'tor to make sure we will not hang on to any deleted objects. 

*/

void CWindowServer::CDefaultAnimationScheduler::CScreenState::ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver)

	{

	const TInt count = iWaitingClients.Count();

	for(TInt i = count-1 ; i >= 0; i--)

		{

		if( &aObserver == &(iWaitingClients[i].iObserver) )

			{

			TWaitingClient& client = iWaitingClients[i];

			client.iObserver.ScreenUpdateComplete(KErrCancel);

			iWaitingClients.Remove(i);

			}

		}

	}

void CWindowServer::CDefaultAnimationScheduler::CScreenState::WaitForRedraws(MWsAnimationScheduler::MScreenUpdateObserver& aObserver, TInt aNumRedraws)

	{

	const TUint targetFrame = iFrameCount + aNumRedraws;

	TWaitingClient request(aObserver, targetFrame);

	TInt err = iWaitingClients.Append(request);

	if(err != KErrNone)

		{

		//If OOM and already have 8 waiting clients we will not accept a 9th client

		aObserver.ScreenUpdateComplete(KErrNoMemory);

		}

	}

void CWindowServer::CDefaultAnimationScheduler::CScreenState::ReleaseRemainingClients()

	{

	const TInt count = iWaitingClients.Count();

	for(TInt i = count-1; i >= 0; i--)

		{

		TWaitingClient& client = iWaitingClients[i];

		client.iObserver.ScreenUpdateComplete(KErrNone);

		iWaitingClients.Remove(i);

		}

	}

void CWindowServer::CDefaultAnimationScheduler::CScreenState::ReleaseClientsWaitingFor(TUint aCurrentFrame)

	{

	const TInt count = iWaitingClients.Count();

	for(TInt i = count-1; i >= 0; i--)

		{

		TWaitingClient& client = iWaitingClients[i];

		if(aCurrentFrame >= client.iTargetFrame)

			{

			client.iObserver.ScreenUpdateComplete(KErrNone);

			iWaitingClients.Remove(i);

			}

		}

	}

/** 

Invoked when the rendering pipline signals that it is ready to recieve updates.

*/

void CWindowServer::CDefaultAnimationScheduler::CScreenState::RunL() 

	{

	iFrameCount++;

	//Complete any clients waiting for this frame

	ReleaseClientsWaitingFor(iFrameCount);

	iScreenUpdateDetails.iScheduler->ProcessUpdateCompletion (iScreenUpdateDetails.iScreenNumber);

	if(!IsActive())

		{

		//No further pending frames, release all remaining clients

		ReleaseRemainingClients();

		}

	}

void CWindowServer::CDefaultAnimationScheduler::ProcessUpdateCompletion (TInt aScreenNumber)

	{

	// Stop all waitloops related to the specified screen.

	TInt waitLoopCount = iRedrawWaitLoop.Count();

	for (TInt waitLoop = 0; waitLoop < waitLoopCount; waitLoop++)

		if (iRedrawWaitLoop[waitLoop]->IsStarted() && (iRedrawWaitLoop[waitLoop]->iScreenNumber == aScreenNumber))

			iRedrawWaitLoop[waitLoop]->AsyncStop();

	// Perform any outstanding redraws on the specified screen.

	ScheduleUpdate (aScreenNumber, ETrue);

	}

void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& aScreen, MWsAnimationScheduler::MScreenUpdateObserver& aObserver)

	{

	TInt screenNumber = ScreenNumber (aScreen);

	TInt redrawCount = 0;

	// redrawCount is the number of times we should wait for redraws to complete.

	// If a redraw is not currently active then we need to wait (at most) once: for

	// any outstanding scheduled update to complete.

	// If a redraw is currently active then we need to wait (at most) twice: once for

	// the current update to complete, and once for any outstanding scheduled update to complete.   

	if (!iScreenState[screenNumber]->IsActive())

		{

		// No animation in progress, so force a redraw of due updates.

		ScheduleUpdate(screenNumber, ETrue);

		// If there is still nothing drawing, set redrawCount to zero to make sure we do not wait.

		if (!iScreenState[screenNumber]->IsActive())

			{

			redrawCount = 0;

			aObserver.ScreenUpdateComplete(KErrNone);

			}

		else

			{

			redrawCount = 1;

			iScreenState[screenNumber]->WaitForRedraws(aObserver, redrawCount);

			}

		}

	else

		{

		redrawCount = 2;

		iScreenState[screenNumber]->WaitForRedraws(aObserver, redrawCount);

		}

	}

void CWindowServer::CDefaultAnimationScheduler::ClearScreenUpdateObserver(const MWsAnimationScheduler::MScreenUpdateObserver& aObserver)

	{

	const TInt count = iScreenState.Count();

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

		{

		iScreenState[screenNumber]->ClearScreenUpdateObserver(aObserver);

		}

	}

/**

Switch to deactivate animation or drawing (based on setting of iInactivityBehaviour).

See InvokeDueAnimation().

*/

void CWindowServer::CDefaultAnimationScheduler::OnInactive()

	{

	iInactive = ETrue;

	}

/**

Switch to deactivate/activate animation or drawing (based on setting of iInactivityBehaviour).

See InvokeDueAnimation().

*/	

void CWindowServer::CDefaultAnimationScheduler::OnActive()

	{

	iInactive = EFalse;

	if(iInactiveDraws)

		{

		iInactiveDraws = EFalse;

		iIdleInitiator->CallBack();

		}

	}

void CWindowServer::CDefaultAnimationScheduler::ScheduleRedraw(MWsScreen& aScreen,const TTime& aWhen)

	{

	iRedrawScheduled = ETrue;

	ScheduleAnimation(aScreen, aWhen);

	}

/** 

Given a MWsScreen pointer, return an integer value representing the ordinal position

of the screen in the Window Server.

*/

TInt CWindowServer::CDefaultAnimationScheduler::ScreenNumber(MWsScreen& aScreen) const

	{

	TInt numberOfScreens = CWsTop::NumberOfScreens();

	TInt theScreen;

	for (theScreen = 0; theScreen < numberOfScreens; theScreen++)

		if (CWsTop::Screen(theScreen) == &aScreen) 

			break;

	WS_ASSERT_DEBUG(theScreen < numberOfScreens, EWsPanicWsGraphic);

	return theScreen;

	}

/**

Perform redraw and return only when completed.

NOTE: This method uses CActiveSchedulerWait to run a "modal wait loop" while the

		redraw complete signal is pending. When the signal is recieved, AsyncStop() is

		invoked on all active wait loops for the signalling screen. 

*/

void CWindowServer::CDefaultAnimationScheduler::DoRedrawNow(MWsScreen& aScreen)

	{	

	TInt screenNumber = ScreenNumber (aScreen);

	TInt redrawCount = 0;

	// redrawCount is the number of times we should wait for redraws to complete.

	// If a redraw is not currently active then we need to wait (at most) once: for

	// any outstanding scheduled update to complete.

	// If a redraw is currently active then we need to wait (at most) twice: once for

	// the current update to complete, and once for any outstanding scheduled update to complete.	

	if (!iScreenState[screenNumber]->IsActive())

		{		

		// No animation in progress, so force a redraw of due updates.

		ScheduleUpdate(screenNumber, ETrue);

		// If there is still nothing drawing, set redrawCount to zero to make sure we do not wait.

		if (!iScreenState[screenNumber]->IsActive())

			redrawCount = 0;

		else

			redrawCount = 1;