// 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"

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

	{

public:

	enum TInactivityBehaviour

		{

		EStopAnimation,

		EStopAllDrawing,

		EIgnore,

		};

	class CKickBack;

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

	TInt RemoveGraphicDrawer(const TGraphicDrawerId &aId);

private:

	static TBool OnIdleCallBack(TAny* aAny);

	void OnIdleCallBack(TBool aForceRedraw);

	static TBool OnTickCallBack(TAny* aAny);

	void OnTickCallBack();

	static TBool OnKickBack(TAny* aAny);

	void OnKickBack();

private:

	MWsGraphicDrawerEnvironment& iEnv;

	static const TInt64 KRedrawGrace;

	static const TInt64 KAnimationGrace;

	static const TInt64 KDsaAnimationGrace;

	CAsyncCallBack* iIdleInitiator;

	CPeriodic* iTick;

	CKickBack* iKickBack;

	struct TSchedule

		{

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

		TBool iSchedule;

		TTime iWhen;

		TInt iGeneration;

		};

	RArray<TSchedule> iSchedule;

	TInt iGeneration;

	RArray<TGraphicDrawerId> iInvalidated;

	TBool iInvalidateAll; // if we could not add to iInvalidated, we have to instead redraw everything

	TTime iWhenDesired;

	TBool iInactive;

	TBool iInactiveDraws;

	TTime iExpectedTime;

	TBool iRedrawScheduled;

	TInt64 iRedrawGracePeriod;

	TInt64 iAnimationGracePeriod;

	TInt64 iDsaAnimationGracePeriod;

	TInactivityBehaviour iInactivityBehaviour;

	};

TInt CWindowServer::CDefaultAnimationScheduler::RemoveGraphicDrawer(const TGraphicDrawerId &aId)

	{

	TInt index=iInvalidated.Find(aId);

	if (index!=KErrNotFound)

		iInvalidated.Remove(index);

	return index;

	}	

class CWindowServer::CDefaultAnimationScheduler::CKickBack: public CActive

	{

public:

	CKickBack(const TCallBack& aCallBack);

	void ConstructL();

	void RequestKickBack();

	~CKickBack();

private:

	static TInt IdleThreadFunc(TAny* aAny);

	void Loop();

	// from CActive

	void RunL(); // fires when kicked back by the idle thread

	void DoCancel();

private:

	RThread iWservThread;

	RThread iIdleThread;

	TRequestStatus iIdleStatus;

	TCallBack iCallBack;

	};

CWindowServer::CDefaultAnimationScheduler::CKickBack::CKickBack(const TCallBack& aCallBack) :

CActive(EPriorityNormal),

iCallBack(aCallBack)

	{

	CActiveScheduler::Add(this);

	}

void CWindowServer::CDefaultAnimationScheduler::CKickBack::ConstructL()

	{

	_LIT(KIdleThreadName,"NearlyIdleKickBack");

	const TInt KStackSize = 1024;

	User::LeaveIfError(iWservThread.Open(iWservThread.Id()));

	User::LeaveIfError(iIdleThread.Create(KIdleThreadName(),IdleThreadFunc,KStackSize,NULL,this));

	iIdleThread.SetPriority(EPriorityAbsoluteVeryLow);

	iIdleThread.Resume();

	}

void CWindowServer::CDefaultAnimationScheduler::CKickBack::RequestKickBack()

	{

	if (!IsActive())

		{

		iStatus = KRequestPending;

		SetActive();

		TRequestStatus * status = &iIdleStatus;

		iIdleThread.RequestComplete(status, KErrNone);

		}

	}

void CWindowServer::CDefaultAnimationScheduler::CKickBack::Loop()

	{

	FOREVER

		{

		// This is used here for performance reasons. 

		User::WaitForRequest(iIdleStatus); 

		iIdleStatus = KRequestPending;

		if (IsActive()&& (iStatus == KRequestPending))

			{

			TRequestStatus * status = &iStatus;

			iWservThread.RequestComplete(status,KErrNone);

			}

		}

	}

void CWindowServer::CDefaultAnimationScheduler::CKickBack::RunL()

	{

	iCallBack.CallBack();

	}

void CWindowServer::CDefaultAnimationScheduler::CKickBack::DoCancel()

	{

	}

CWindowServer::CDefaultAnimationScheduler::CKickBack::~CKickBack()

	{

	Cancel();

	iWservThread.Close();

	iIdleThread.Kill(0);

	iIdleThread.Close();

	}

TInt CWindowServer::CDefaultAnimationScheduler::CKickBack::IdleThreadFunc(TAny* aAny)

	{

	CKickBack* owner = reinterpret_cast<CKickBack*>(aAny);

	ASSERT(owner);

	if(owner)

		{

		owner->Loop();

		}

	return 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 = 35000; // insist upon 35ms grace for other threads to run when animating

const TInt64 CWindowServer::CDefaultAnimationScheduler::KDsaAnimationGrace = 35000; // insist upon 35ms grace for other threads to run when animating during DSA

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

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

	{

	}

CWindowServer::CDefaultAnimationScheduler::~CDefaultAnimationScheduler()

	{

	iSchedule.Close();

	iInvalidated.Close();

	delete iKickBack;

	delete iIdleInitiator;

	delete iTick;

	}

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;

	_LIT(KDsaAnimationGracePeriod, "DSAANIMATIONGRACEPERIOD");

	tmp = KDsaAnimationGrace;

	WsIniFile->FindVar(KDsaAnimationGracePeriod, tmp);

	iDsaAnimationGracePeriod = tmp;

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

	iTick = CPeriodic::NewL(EWsGraphicAnimatePriority);

	_LIT(KDisableIdleAnimation, "DISABLEIDLEANIMATION");

	if (!WsIniFile->FindVar(KDisableIdleAnimation))

		{

		iKickBack = new CKickBack(TCallBack(OnKickBack,this));

		iKickBack->ConstructL();

		}

	}

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

	{

	if(!iInvalidateAll)

		{

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

			{

			case KErrNone:

				break;

			case KErrAlreadyExists:

				break;

			default:

				iInvalidateAll = ETrue;

				iInvalidated.Reset();

			}

		}

	iIdleInitiator->CallBack();

	}

void CWindowServer::CDefaultAnimationScheduler::OnInactive()

	{

	iInactive = ETrue;

	}

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

	}

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

	{

	OnIdleCallBack(ETrue);

	}

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

	{

	TSchedule schedule;

	schedule.iScreen = &aScreen;

	schedule.iSchedule = ETrue;

	schedule.iWhen = aWhen;

	schedule.iGeneration = iGeneration;

	TBool ok = EFalse;

	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);

	if(0 <= idx)

		{

		if(iSchedule[idx].iSchedule)

			{

			if(iSchedule[idx].iWhen > aWhen)

				{

				iSchedule[idx].iWhen = aWhen;

				}

			}

		else

			{

			iSchedule[idx] = schedule;

			}

		iSchedule[idx].iGeneration = iGeneration;

		ok = ETrue;

		}

	else

		{

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

		}

	if(ok)

		{

		//If the animation runs at very high rate which exceeds the rate WSERV can 

		//perform the rendering, it is possible that WSERV animation loop will monopolize  

		//processor time. 

  		User::After(0);	// to yeild from the animation loop 

		iIdleInitiator->CallBack();

		}

	}

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

	{

	TSchedule schedule;

	schedule.iScreen = &aScreen;

	const TInt idx = iSchedule.FindInUnsignedKeyOrder(schedule);

	if(0 <= idx)

		{

		iSchedule[idx].iSchedule = EFalse;

		}

	}

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

	{

	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);

	ASSERT(self);

	if(self)

		{

		self->OnIdleCallBack(EFalse);

		}

	return EFalse; //ignored by caller

	}

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

	{

	TBool wasActive = EFalse;

	if (iTick->IsActive())

		{

		wasActive = ETrue;

		iTick->Cancel(); // stop ticker, as we'll reschedule if necessary

		}

	if (aForceRedraw)

		{

		// Don't need to update iExpectedTime as we will not schedule a tick.

		// Don't need to update iWhenDesired as we will not schedule a kick-back.

		OnTickCallBack();

		return;

		}

	TBool tick = (iInvalidateAll || iInvalidated.Count());

	TTimeIntervalMicroSeconds next = 0LL;

	const TInt count = iSchedule.Count();

	TTime now;

	now.UniversalTime();

	if(count)

		{

		// work out the next wanted tick

		TBool animTick = EFalse;

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

			{

			if(iSchedule[i].iSchedule)

				{

				const TTime when = iSchedule[i].iWhen;

				const TTimeIntervalMicroSeconds fromNow = when.MicroSecondsFrom(now);

				if(!animTick || (fromNow < next))

					{

					animTick = ETrue;

					tick = ETrue;

					next = fromNow;

					iWhenDesired = when;

					}

				}

			}

		}

	if(tick)

		{

		TInt64 grace;

		if (iRedrawScheduled)

			grace = iRedrawGracePeriod;

		else if (EFalse) // DSA active

			grace = iDsaAnimationGracePeriod;

		else

			grace = iAnimationGracePeriod;

		if (wasActive)

			{

			TInt64 minimum = iExpectedTime.MicroSecondsFrom(now).Int64();

			if (minimum >= 0 && grace > minimum)

				grace = minimum;

			}

		if (next.Int64() <= 0)

			next = 0LL ;  // No kickback/tick is needed. Make sure next == default grace period.

		if(next < grace)

			{

			next = grace;

			if (iKickBack)

				iKickBack->RequestKickBack();

			}

		else if (next > KHalfHour)

			next = KHalfHour;

		iExpectedTime=now + next;

		if (next.Int64() > 0)

			{

			iTick->Start(next.Int64(),0,TCallBack(OnTickCallBack,this));

			}

		else

			{

			OnTickCallBack(); // scheduling for 0 doesn't actually execute immediately

			}

		}

	}

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

	{

	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);

	ASSERT(self);

	if(self)

		{

		self->OnKickBack();

		}

	return EFalse; //ignored by caller

	}

void CWindowServer::CDefaultAnimationScheduler::OnKickBack()

	{

	if (iTick->IsActive())

		{

		iTick->Cancel();

		TTime now;

		now.UniversalTime();

		TTimeIntervalMicroSeconds fromNow = iWhenDesired.MicroSecondsFrom(now);

		if (fromNow < 0)

			{

			OnTickCallBack();

			}

		else

			{

			if (fromNow > KHalfHour)

				fromNow = KHalfHour;

			iTick->Start(fromNow.Int64(),0,TCallBack(OnTickCallBack, this));

			}

		}

	}

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

	{

	CDefaultAnimationScheduler* self = reinterpret_cast<CDefaultAnimationScheduler*>(aAny);

	ASSERT(self);

	if(self)

		{

		self->OnTickCallBack();

		}

	return EFalse;

	}

void CWindowServer::CDefaultAnimationScheduler::OnTickCallBack()

	{

	iTick->Cancel();

	switch(iInactivityBehaviour)

		{

		case EStopAnimation :

			// only client redraws if inactive. server side drawing stopped.

			if(iInactive && !iRedrawScheduled) 

				{

				iInactiveDraws = ETrue;

				return;

				}