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

// Top level window server code

// 

//

#include "wstop.h"

#include <hal.h>

#include <graphics/fbsdefs.h>

#include "W32STD.H"

#include "ANIM.H"

#include "gc.h"

#include "playbackgc.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "EVENT.H"

#include "KEYCLICK.H"

#include "panics.h"

#include "inifile.h"

#include "pointer.h"

#include "WSGRAPHICDRAWERFACTORY.H"

#include "redrawmsgwindow.h"

#include <Graphics/WSGRAPHICDRAWERINTERFACE.H>

#include "WsMemMgr.h"

#include "backedupwindow.h"

#include "wsfont.h"

#include "registeredsurfacemap.h"

#include <EGL/egl.h>

#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP

#include <e32power.h>

#endif

#include "registeredsurfacemap.h"

#include "windowelementset.h"

#include "wspluginmanager.h"

// IDs of p&s properties that optionally contain callbacks that may be used

// to release singletons owned by libraries at shutdown in order to make 

// the memory leak tests work.

// By convention, the ID is the same as the UID3 of the libary.

static TBool gReleaseSingletonsOnExit = EFalse;

static const TUid KOpenWfcImplCleanupKey = {0x10286FC4};     

static const TUid KOpenWfcInteropCleanupKey = {0x10286FC5};

typedef CDebugLogBase *(*CreateDebugLog)(TBool aIsFirst, TDesC &aParams);

CWsActiveScheduler* CWsActiveScheduler::Static()

	{

	return static_cast<CWsActiveScheduler*>(CActiveScheduler::Current());

	}

CWsActiveScheduler::CWsActiveScheduler(): iNumSamples(100)

	{

	iRun = User::FastCounter();

	if((KErrNone == HAL::Get(HALData::EFastCounterFrequency,iFastCounterFreq)) && iFastCounterFreq)

		{

		iData = reinterpret_cast<TSample*>(User::AllocZ(sizeof(TSample)*iNumSamples));

		}

	}

CWsActiveScheduler::~CWsActiveScheduler()

	{

	User::FreeZ(reinterpret_cast<void*&>(iData));

	}

void CWsActiveScheduler::PrepareDraw()

	{

	iRunDraw = User::FastCounter();

	}

void CWsActiveScheduler::CancelPrepare()

	{

	}

void CWsActiveScheduler::StartDraw()

	{

	TTime now;

	now.UniversalTime();

	TUint64 duration = now.MicroSecondsFrom(iRunDraw).Int64();

	iPreparing += duration;

	iRunDraw = now;

	if(iData)

		{

		iData[iCurrent].iStart = iRunDraw;

		}

	iDraws++;

	}

void CWsActiveScheduler::DrawStats(TInt& aUpdatesPerSecond,TInt64& aPixelsPerSecond,TInt aWindowInSeconds) const

	{

	aUpdatesPerSecond = 0;

	aPixelsPerSecond = 0;

	if(iData)

		{

		// work out statistic

		TTime window;

		window.UniversalTime();

		window -= TTimeIntervalSeconds(aWindowInSeconds);

		TUint32 pixels = 0;

		TInt64 duration = 0;

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

			{

			if(iData[i].iStart >= window)

				{

				pixels += iData[i].iPixels;

				duration += iData[i].iDuration;

				aUpdatesPerSecond++;

				}

			}

		if(aUpdatesPerSecond && duration)

			{

			const TReal pixelsPerMicroSecond = (static_cast<TReal>(pixels) / static_cast<TReal>(duration));

			aPixelsPerSecond = static_cast<TInt64>(pixelsPerMicroSecond * 1000000.0);

			aUpdatesPerSecond /= aWindowInSeconds;

			}

		}

	}

void CWsActiveScheduler::StopDraw(TInt aPixelsUpdated)

	{

	TTime now;

	now.UniversalTime();

	TUint32 duration = now.MicroSecondsFrom(iRunDraw).Int64();

    // do recording

	if(iData)

		{

		iData[iCurrent].iDuration = now.MicroSecondsFrom(iData[iCurrent].iStart).Int64();

		iData[iCurrent].iPixels = aPixelsUpdated;

		if(++iCurrent >= iNumSamples)

			{

			iCurrent = 0;

			}

		}

	iDrawing += duration;

	}

void CWsActiveScheduler::WaitForAnyRequest()

	{

	TTime stop;

	stop.UniversalTime();

	iTotal += stop.MicroSecondsFrom(iRun).Int64();

	CActiveScheduler::WaitForAnyRequest();

	iRequests++;

	iRun.UniversalTime();

	iIdle += iRun.MicroSecondsFrom(stop).Int64();

	}

void CWsActiveScheduler::Error(TInt /*aError*/) const

	{

	iErrors++;

	}

void CWsActiveScheduler::AccumReclaimedIdleTime(TInt64 aMicroSeconds)

	{

	iReclaimedIdleTime += aMicroSeconds;

	}

GLREF_C void StateDump(CWsRootWindow* aRootWindow);

GLREF_C void HeapDump();

// Static objects that need to be destroyed on exit

GLDEF_D CDebugLogBase *wsDebugLog=NULL;

GLDEF_D TInt wsDebugLogLevel=0;

GLDEF_D CIniFile *WsIniFile=NULL;

//

GLDEF_D TPtr nullDescriptor(NULL,0);

LOCAL_D CWsActiveScheduler *TheActiveScheduler;

CScreen* CWsTop::iCurrentFocusScreen;

CArrayPtrFlat<CScreen>* CWsTop::iScreens ;

TInt CWsTop::iNumberOfScreens ;

CWsTop::CShellStarter* CWsTop::iShellStarter;

CWsPluginManager *CWsTop::iPluginManager;

CWindowServer *CWsTop::iServer;

RLibrary CWsTop::iDebugLib;

CWsShellLogon *CWsTop::iShell;

const CWsClient *CWsTop::iShellClient;

TBool CWsTop::iPreviousShellClient=EFalse;

TInt CWsTop::iShellBootMode;

TBool CWsTop::iShuttingDown;

TBool CWsTop::iIsFirstLog=ETrue;

CWsWindowBase *CWsTop::iWindowToSendOffEventsTo=NULL;

RTimer CWsTop::iTimer;

TBool CWsTop::iIgnoreSwitchOffEvent=EFalse;

TBool CWsTop::iFadeEnabled=ETrue;

TBool CWsTop::iFinishEveryFlush=EFalse;

TBool CWsTop::iMultiFocusPolicy=EFalse;

#if defined(__WINS__)

TFullName WsSemName;

#endif

const CWsClient* CWsTop::iTriggerHeapCheckOnClientExit=NULL;

TWsCheckHeapOnDisconnectMode CWsTop::iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;

TInt CWsTop::iCheckHeapResult=KErrNotReady;

TBool CWsTop::iDoHeapCheckAndRestart=EFalse;

#define RFbsSession_SendCommand_ShutDownMessage 1	// A FBS message that is not published yet and probably never will be.

static void DefineSingletonKey(const TUid& aSingletonKey)

/**

 * Defines a new property for a singleton key. WServ must only process 

 * singleton keys that it created to prevent a malicious process with the 

 * WriteDeviceData capability causing arbitrary functions to be executed.

 * 

 * @param   aSingeltonKey   The UID of the singleton key to define.

 */

    {

    RThread t;      

    TUid category = { t.SecureId().iId };

    RProperty prop;

    // Write access is restricted to THIS process

    TInt err = prop.Define( category, aSingletonKey.iUid, 

            RProperty::EByteArray, TSecurityPolicy( t.SecureId() ), 

            TSecurityPolicy( t.SecureId() ), sizeof( TCallBack ) );

    if ( err == KErrNone )

        {

        TCallBack cb( NULL, NULL );

        TPckgC<TCallBack> cbPckg( cb );

        // Any error should cause the properties to be ignored

        err = prop.Set( category, aSingletonKey.iUid, cbPckg );    

        }      

    if ( err != KErrNone )

        {

        // A problem occured / the property already existed so for safety

        // the release code should be skipped.

        gReleaseSingletonsOnExit = EFalse;

        }

    prop.Close();

    t.Close();

    }

static void DeleteSingleton( const TUid& aSingletonKey )

/**

 * Deletes a singleton object that was created on WServ's main heap.

 * 

 * @pre     The ws plugins have not been unloaded.

 * @param   aSingletonKey   The UID of the singleton which correponds to an

 *                          RProperty within WServ's category.                       

 */

    {   

    if ( gReleaseSingletonsOnExit )

        {

        RThread t;

        TPckgBuf<TCallBack> cb;

        RProperty prop; 

        TInt err = prop.Get(TUid::Uid(t.SecureId().iId), aSingletonKey.iUid, cb);

        if (err == KErrNone && cb.Length() == sizeof(TCallBack) && 

                cb().iFunction && cb().iPtr == &User::Heap())

            {

            // Callback is only invoked if the heap for the singleton was the 

            // WServ heap because the WServ memory leak tests only check this

            // heap.

            cb().CallBack();

            }

        // Errors are ignored because the purpose of this function is to free

        // singletons in order top make memory leak checks pass.

        prop.Close();

        t.Close();

        }

    }

void CWsTop::DeleteStaticsL()

	{

	iShuttingDown=ETrue;

	CClick::DeleteStatics();

	TWsPointer::Stop();

	CWsClient::DeleteStatics();

//

	delete iShellStarter;

	iServer->DestroySessionsForShutdown();

	CWsBackedUpWindow::StaticDestroy();

	delete iShell;

	DisableLogging();

	CEventQueue::DeleteStaticsL();

	CWsSpriteBase::DeleteStatics();

	CWsGc::DeleteStatics();

	CPlaybackGc::DeleteStatics();

	CWsAnimDll::DeleteStatics();

	CWsFontCache::DestroyInstance();

	iScreens->ResetAndDestroy();

	delete iScreens;

	delete iServer;

	TWindowServerEvent::DeleteStatics();

	// Free singletons on WServ heap created by libraries. Must be called

	// BEFORE iPluginManager is deleted otherwise the library code could have

	// been unloaded.

	DeleteSingleton(KOpenWfcImplCleanupKey);

	DeleteSingleton(KOpenWfcInteropCleanupKey);

	eglReleaseThread();

	if (!iDoHeapCheckAndRestart)

		{

		RFbsSession::GetSession()->SendCommand(RFbsSession_SendCommand_ShutDownMessage);		//This line is just being tidy, never really does anything useful.

		}

	RFbsSession::Disconnect();

	iDebugLib.Close();

	iTimer.Close();

	TWsPointer::DeleteStatics();

	delete TheActiveScheduler;

	// iPluginManager is not created in InitStaticsL because plugins need to be loaded 

	// before E32Main's loop for EcomSession allocations issues

	delete iPluginManager;

	}

RWsTextCursor *CWsTop::CurrentTextCursor()

	{

	if(iCurrentFocusScreen && FocusWindowGroup())

		{

		return FocusWindowGroup()->TextCursor();

		}

	else

		{

		return NULL;

		}

	}

CWsClient *CWsTop::FocusWindowGroupOwner()

	{

	return(FocusWindowGroup() ? FocusWindowGroup()->WsOwner():NULL);

	}

void CWsTop::ClientDestroyed(const CWsClient *aClient)

	{

	if (aClient==iShellClient)

		iShellClient=NULL;

	}

void CWsTop::NewSession(const CWsClient *aClient)

	{	

	if (iShellClient==NULL && iShell)

		{

#if defined(__WINS__)

		RThread proc;

		proc=aClient->Client();

#else

		RProcess proc;

		aClient->Client().Process(proc);

#endif

		TFullName procName = proc.FullName();

		// Before comparing the proc name with iShell name , truncate the proc name up to the actual name

		// referring to the process, by removing the part which starts with ':', if exists.

		TInt colonLocation = procName.Locate(':');

		if( KErrNotFound != colonLocation)

			{

			procName = procName.Left(colonLocation);

			}

		if (procName ==iShell->FullName())

			{

			iShellClient=aClient;

			if (!iPreviousShellClient)

				{

				iPreviousShellClient=ETrue;

				aClient->Screen()->RootWindow()->SetColorIfClear();

				}

			}

#if !defined(__WINS__)

		proc.Close();

#endif

		}	

	}

void CWsTop::SessionExited(CWsClient *aClient)

	{

	if (iShuttingDown)

		{

		RProcess proc;

		TInt err=aClient->Client().Process(proc);

		if (err==KErrNone && proc.Id()!=RProcess().Id())

			proc.Kill(0);

		else

			const_cast<RThread&>(aClient->Client()).Kill(0);

		if (err==KErrNone)

			proc.Close();

		}

	else if (iHeapCheckMode!=EWsCheckHeapOnDisconnectModeNone && aClient==iTriggerHeapCheckOnClientExit)

		{

		if (iHeapCheckMode==EWsCheckHeapOnDisconnectModeOnce)

			{

			iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;

			}

		iTriggerHeapCheckOnClientExit=NULL;

		iDoHeapCheckAndRestart=ETrue;

		Exit();

		}

	if (iServer->SessionCount()==1 && iShellBootMode==EShellBootModeNoReboot && iShell==NULL)

		StartShell();

	}

void CWsTop::RunServerL()

	{

	InitStaticsL();

	CWsMemoryManager* memMgr = CWsMemoryManager::NewLC();

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(memMgr);

	DeleteStaticsL();

	}

void CWsTop::InitStaticsL()

	{

	iShuttingDown=EFalse;

	// By default shell should be started.

	TBool startShell = ETrue;

	iCurrentFocusScreen = 0;

	// The windows server has been invoked.

	// This may have been from the system starter (via a

	// start up rss file)  

	// This block looks for a "-NoShell" argument in the invocation.

	// The existence of the argument means that shell does not need to be 

	// invoked from here because the new system starter

	// is in charge, and it will do it if required.

	_LIT(KNoShell,"-NOSHELL");

	TInt argLen = User::CommandLineLength();

	if(argLen)

		{

		HBufC* arg = HBufC::NewLC(argLen);

		TPtr argPtr = arg->Des();

		User::CommandLine(argPtr);

		argPtr.UpperCase();

		if(KErrNotFound != argPtr.Find(KNoShell))

			{

			// Don't start the shell. It will be started if required by 

			// the system starter.

			startShell = EFalse;

			}

		CleanupStack::PopAndDestroy(arg);

		}

	TheActiveScheduler=new(ELeave) CWsActiveScheduler;

	CActiveScheduler::Install(TheActiveScheduler);

	// WsIniFile is already created (before E32Main's Loop)

	_LIT(KWSERVIniFileVarLogEnable,"LOGENABLE");

	TInt loggingLevel;

	if (WsIniFile->FindVar(KWSERVIniFileVarLogEnable,loggingLevel))

		{

		EnableLogging(EDoNotReloadWsIni);

		if (wsDebugLog)

			{

			wsDebugLog->SetLoggingLevel(loggingLevel);

			}

		}

	_LIT(KWSERVIniFileVarFadeEnable,"FADEDISABLE");

	iFadeEnabled = !WsIniFile->FindVar(KWSERVIniFileVarFadeEnable);

	_LIT(KWSERVIniFileVarFinishEveryFlush,"FINISHEVERYFLUSH");

	iFinishEveryFlush = WsIniFile->FindVar(KWSERVIniFileVarFinishEveryFlush);

	_LIT(KWSERVIniFileVarSwitchOffEvent,"IGNORESWITCHOFFEVENT");

	iIgnoreSwitchOffEvent = WsIniFile->FindVar(KWSERVIniFileVarSwitchOffEvent);	

	iPluginManager = CWsPluginManager::NewL(); // need to be constructed before iServer!

	iServer=CWindowServer::NewL();

	CClick::InitStaticsL();

	RProcess wservProc;

	if (!wservProc.DefaultDataPaged())

	{

		iServer->SetPinClientDescriptors(ETrue);

	}

	User::LeaveIfError(FbsStartup());

	User::LeaveIfError(RFbsSession::Connect());

	User::LeaveIfError(iTimer.CreateLocal());

	TWindowServerEvent::InitStaticsL();

	CWsClient::InitStaticsL();

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

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

	// Check that the INI file matches the HAL

	WS_ASSERT_ALWAYS(WsIniFile->NumberOfScreens()<=iNumberOfScreens, EWsPanicScreenInformationError);

	iScreens = new (ELeave) CArrayPtrFlat<CScreen>( iNumberOfScreens ) ;  //

	// now construct screens for as long as there is information

	TInt ii ;

	for ( ii = 0 ; ii < iNumberOfScreens ; ++ii )

		{

		InitScreenL( ii ) ;

		}

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

	iCurrentFocusScreen = (*iScreens)[0] ;

	iServer->StartL();

	CWsFontCache::CreateInstanceL();

	CWsGc::InitStaticsL();

	CPlaybackGc::InitStaticsL();

	CWsSpriteBase::InitStaticsL();

	CEventQueue::InitStaticsL();

//

	CWsAnimDll::InitStaticsL();

//

	TInt bootMode=0;

	_LIT(KWSERVIniFileVarReboot,"REBOOT");

	WsIniFile->FindVar(KWSERVIniFileVarReboot,bootMode);

	if (bootMode>=0 && bootMode<=2)