// 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 <Graphics/WSGRAPHICDRAWERINTERFACE.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);

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 ();

	CPeriodic* iUpdateOn;

	TTime      iExpectedTickTime;

	TScreenUpdateDetails iScreenUpdateDetails;

	RArray<TGraphicDrawerId> iInvalidated;

	TBool 		iInvalidateAll;

private:

	CScreenState (CDefaultAnimationScheduler* aScheduler, TInt aScreenOrdinal);

	void ConstructL ();

	void RunL();

	void DoCancel() 

		{

		TRequestStatus* tmpTRS = &iStatus;

		User::RequestComplete(tmpTRS, KErrNone);

		};

	};

// 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);

	CActiveScheduler::Add(this);

	}

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

	{

	CActive::Cancel();

	iInvalidated.Close();

	delete iUpdateOn;

	}

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

	{

	CActive::SetActive ();

	}

/** 

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

*/

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

	{

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

	}

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);

	}

/**

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;

		}

	else

		redrawCount = 2;

	// Wait for the sepecified number of redraws.

	if (redrawCount)

		{

		// Allocate the wait loop on the stack so we are not subject to heap OOM.

		TBuf8<sizeof (CScreenUpdateWait)> buf;

		Mem::FillZ(&buf, sizeof (CScreenUpdateWait));

		CScreenUpdateWait* waitLoop = new (&buf) CScreenUpdateWait(screenNumber);

		if (iRedrawWaitLoop.Append(waitLoop) == KErrNone)

			{

			// Run the active scheduler while updates are active

			while (redrawCount-- && iScreenState[screenNumber]->IsActive())

				waitLoop->Start();

			iRedrawWaitLoop.Remove(iRedrawWaitLoop.Count() - 1);			

			}

		waitLoop->~CScreenUpdateWait();

		}

	}

/**

Schedule an update for a specific screen at a given point in time.

*/ 

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

	{	

	TSchedule schedule;

	schedule.iScreen = &aScreen;

	schedule.iScheduled = ETrue;

	schedule.iWhen = aWhen;

	schedule.iScreenNumber = ScreenNumber (aScreen);

	schedule.iRedraw = iRedrawScheduled;

	iRedrawScheduled = EFalse;

	TBool ok = EFalse;

	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);

	if(0 <= idx)

		{

		TSchedule& currSchedule=iSchedule[idx];

		if(currSchedule.iScheduled)

			{

			if(currSchedule.iWhen > aWhen)

				{

				currSchedule.iWhen = aWhen;

				}

			}

		else

			{

			currSchedule = schedule;

			}

		ok = ETrue;

		}

	else

		ok = (KErrNone == iSchedule.InsertInUnsignedKeyOrder(schedule));

	if(ok)

		iIdleInitiator->CallBack();

	}

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

	{

	TSchedule schedule;

	schedule.iScreen = &aScreen;

	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);

	if(0 <= idx)

		iSchedule[idx].iScheduled = EFalse;

	}

TBool CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TAny* aAny)

	{

	WS_ASSERT_DEBUG(aAny, EWsPanicWsGraphic);

	if(aAny)

		static_cast<CDefaultAnimationScheduler*>(aAny)->OnIdleCallBack(EFalse);

	return EFalse; //ignored by caller

	}

void CWindowServer::CDefaultAnimationScheduler::OnIdleCallBack(TBool aForce)

	{

	const TInt screenCount = iEnv.ScreenCount();

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

		ScheduleUpdate (ii, aForce);

	}

/** 

@return The number of microseconds (from now) that the specified scheduled update should be run at. This

takes into account any set grace period and protects the scheduler from entering an infinite loop servicing

animations with back-to-back frame updates.

*/

TTimeIntervalMicroSeconds CWindowServer::CDefaultAnimationScheduler::GetDueDelta (TBool aForceRedraw, TSchedule* aScheduledUpdate)

	{

	WS_ASSERT_DEBUG(aScheduledUpdate, EWsPanicWsGraphic);

	WS_ASSERT_DEBUG(aScheduledUpdate->iScheduled, EWsPanicWsGraphic);

	TTime now;

	TInt64 grace = I64LIT(0); 

	TTimeIntervalMicroSeconds thisUpdateDueIn = I64LIT(0); //Microseconds from now

	// Only use grace periods if not forcing due updates.

	if (!aForceRedraw)

		{

		if (aScheduledUpdate->iRedraw)

			grace = iRedrawGracePeriod;

		else

			grace = iAnimationGracePeriod;

		}

	now.UniversalTime();

	thisUpdateDueIn = aScheduledUpdate->iWhen.MicroSecondsFrom(now);

	// Add the grace period if the update is due in less time than the grace period.

	if (thisUpdateDueIn < grace)

		thisUpdateDueIn = grace;

	else if (thisUpdateDueIn > KHalfHour)

		thisUpdateDueIn = KHalfHour;

	return thisUpdateDueIn;

	}

/**

Schedule an actual screen update at the point in time at which it is due. The due time may be modified by

this method based on any "grace period" values.

@param aScreen		Screen number to update.

@param aForceRedraw Force redraws that are due. This causes grace periods not to be used.

*/

void CWindowServer::CDefaultAnimationScheduler::ScheduleUpdate (TInt aScreenNumber, TBool aForceRedraw)

	{	

	// Schedule updates for any invalidated regions.

	RedrawAllInvalidatedRegions (aScreenNumber);

	TSchedule* scheduledUpdate = GetScheduledScreenUpdate(aScreenNumber);

	if (scheduledUpdate)

		{

		WS_ASSERT_DEBUG(scheduledUpdate->iScheduled, EWsPanicWsGraphic);

		WS_ASSERT_DEBUG(aScreenNumber < iScreenState.Count(), EWsPanicWsGraphic);

		CScreenState& screenState = *iScreenState[aScreenNumber];

		// Initiate redraw if scheduled and not currently updating the display.