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

//

#include <apgtask.h>

#include <apgwgnam.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "vwsinternal.h"

#include "vwsdefpartner.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "VWSERVER.H"

#include "VWSSESSN.H"

#include "VWSEVENT.H"

#include "VWSWEVNT.H"

#include "VWSADDOB.H"

#include "VWSPRIV.H"

#include "VWSDEBUG.H"

#include "vwspatchdata.h"

#include <barsc2.h>

#include <barsread2.h>

#include <f32file.h> 

#include <u32hal.h>

//

// Constants.

//

const TInt KVwsSystemDefaultViewArrayGranularity=2;

const TInt KDefaultClientRequestTimeOutDuration=1000000;

const TInt KDefaultServerEventTimeOutDuration=10000000;

_LIT(KPriorityFilename,"Z:\\resource\\apps\\PrioritySet.rsc");

const TUint8 KPolicyElementSID = 0;

const TUint8 KPolicyPowerMgmt = 1;

const TInt KEiksrvsSid=0x10003a4a;

const TUint KRangeCount = 5; 

const TInt KVwsServerRanges[KRangeCount] = 

	{	

	EFirstUnrestrictedOpcodeInVws,

	EFirstOpcodeNeedingCustomCheckInVws,

	EFirstOpcodeNeedingSecureIdInVws,	

	EFirstOpCodeNeedingPowerMgmt,

	EVwsFirstUnusedOpcode,

	};

const TUint8 KElementsIndex[KRangeCount] =

	{

	CPolicyServer::EAlwaysPass,		//Always passing no capability required [EFirstUnrestrictedOpcodeInVws-(EFirstOpcodeNeedingCustomCheckInVws-1)]

	CPolicyServer::ECustomCheck,	//Requires Custom check	[EFirstOpcodeNeedingCustomCheckInVws-(EFirstOpcodeNeedingSecureIdInVws-1)]

	KPolicyElementSID,				//Requires SID to be of Eiksrvs ie.0x10003a4a  [EFirstOpcodeNeedingSecureIdInVws-(EFirstOpCodeNeedingPowerMgmt-1)]

	KPolicyPowerMgmt,				//Requires PowerMgmt capability [EFirstOpCodeNeedingPowerMgmt-(EVwsFirstUnusedOpcode-1)]

	CPolicyServer::ENotSupported,	//Not Supported		

	};

const CPolicyServer::TPolicyElement KPolicyElements[] = 

	{

	{_INIT_SECURITY_POLICY_S0(KEiksrvsSid), CPolicyServer::EFailClient}, 

	{_INIT_SECURITY_POLICY_C1(ECapabilityPowerMgmt), CPolicyServer::EFailClient} 

	};

const CPolicyServer::TPolicy KVwsServerPolicy =

	{

	CPolicyServer::EAlwaysPass, 

	KRangeCount,

	KVwsServerRanges,

	KElementsIndex, 	 

	KPolicyElements 	

	};

//

// CVwsServer.

//

#ifdef __DO_LOGGING__

CVwsServer::CVwsServer(TInt aPriority,MVwsAppStarter& aAppStarter)

	: CPolicyServer(aPriority,KVwsServerPolicy),

	  iAppStarter(aAppStarter),

	  iSystemDefaultViewIdArray(KVwsSystemDefaultViewArrayGranularity),

	  iClientRequestTimeOut(KDefaultClientRequestTimeOutDuration),

	  iServerEventTimeOut(KDefaultServerEventTimeOutDuration),

	  iForegroundChangeWhileEventsOutstanding(EFalse),

	  iIsServerEventTimeOutDisabled(0),	

	  iNoActivationRequests(0),

	  iEnableServerBlankScreen(ETrue),

	  iEnableBoostAppPriorityBeforePanic(KVwsBoostAppPriorityBeforePanic)

	{

	}

#else

CVwsServer::CVwsServer(TInt aPriority,MVwsAppStarter& aAppStarter)

	: CPolicyServer(aPriority,KVwsServerPolicy),

	  iAppStarter(aAppStarter),

	  iSystemDefaultViewIdArray(KVwsSystemDefaultViewArrayGranularity),

	  iClientRequestTimeOut(KDefaultClientRequestTimeOutDuration),

	  iServerEventTimeOut(KDefaultServerEventTimeOutDuration),

	  iForegroundChangeWhileEventsOutstanding(EFalse),

	  iIsServerEventTimeOutDisabled(0),

	  iEnableServerBlankScreen(ETrue),

	  iEnableBoostAppPriorityBeforePanic(KVwsBoostAppPriorityBeforePanic)

	{

	}

#endif

EXPORT_C CVwsServer* CVwsServer::NewL(MVwsAppStarter& aAppStarter)

	{

	CVwsServer *pS=new CVwsServer(CActive::EPriorityStandard,aAppStarter);

	__ASSERT_ALWAYS(pS!=NULL,PanicServer(EVwsServerCreate));

	pS->ConstructL();

	pS->StartL(KViewServerName);

	return pS;

	}

CSession2* CVwsServer::NewSessionL(const TVersion &aVersion,const RMessage2& aMessage) const

	{

	// Check version supported.

	TVersion version(KVwsMajorVersionNumber,KVwsMinorVersionNumber,KVwsBuildVersionNumber);

	if (!User::QueryVersionSupported(version,aVersion))

		{

		User::Leave(KErrNotSupported);

		}

	RThread thread;

	User::LeaveIfError(aMessage.Client(thread));

	const TThreadId threadId(thread.Id());

	thread.Close();

	return CVwsSession::NewL(threadId,CONST_CAST(CVwsServer&,*this));

	}

EXPORT_C CVwsServer::~CVwsServer()

	{

	delete iWServSessionHandler;

	delete iEventQueue;

#ifdef __DO_LOGGING__

	CVwsLog::ShutdownLog();

#endif

	}

void CVwsServer::ConstructL()

	{

	// required for handling intercepting window

	iWServSessionHandler=CVwsWServSessionHandler::NewL(*this);

#ifdef __DO_LOGGING__

	iEventQueue=new(ELeave) CVwsEventQueue(_L("Server Queue"));

	CVwsLog::StartLogL();

#else

	iEventQueue=new(ELeave) CVwsEventQueue;

#endif

	RFs fs;

	iPrioritySet=CActive::EPriorityStandard;

	CleanupClosePushL(fs);

	if(fs.Connect()==KErrNone)

		{

		CResourceFile* file=NULL;

		TRAPD(err, file=CResourceFile::NewL(fs, KPriorityFilename, 0, 0));

		if(err == KErrNone)

			{

			CleanupStack::PushL(file);

			RResourceReader reader;

			reader.OpenL(file, 2);

			CleanupClosePushL(reader);

			iPrioritySet=reader.ReadUint32L();

			CleanupStack::PopAndDestroy(&reader);

			CleanupStack::PopAndDestroy(file);

			}

		fs.Close();

		}

	CleanupStack::PopAndDestroy(&fs);

#ifdef __WINS__

	// KVwsBoostAppPriorityBeforePanic is a Rom patchable constant, so need an emulator equivalent

	// if WINS then read value from epoc.ini requires licencees to set property in epoc.ini. 

	// Usage: In epoc.ini patchdata_viewsrv_dll_KVwsBoostAppPriorityBeforePanic 1

	TInt valueOfKVwsBoostAppPriorityBeforePanic = 0;

	if (UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"patchdata_viesrv_dll_KVwsBoostAppPriorityBeforePanic",&valueOfKVwsBoostAppPriorityBeforePanic) == KErrNone)

		{

		iEnableBoostAppPriorityBeforePanic = valueOfKVwsBoostAppPriorityBeforePanic;

		}

#endif

	if (iEnableBoostAppPriorityBeforePanic)

		{

		CVwsStartupAware* startupAware = new(ELeave)CVwsStartupAware(*this);

		TInt err = startupAware->Start();

		if (err != KErrNone)

			{

			HandleInitializationFinished();

			delete startupAware;

			}

		}

 	}

CVwsStartupAware::CVwsStartupAware(CVwsServer& aServer)

	:CActive(CActive::EPriorityStandard),iServer(aServer)

	{

	CActiveScheduler::Add(this); 

	}

CVwsStartupAware::~CVwsStartupAware()

	{

	Cancel();

	iStateAwareSession.Close();

	}

TInt CVwsStartupAware::Start()

	{

	TInt err = iStateAwareSession.Connect(KSM2UiServicesDomain3);

	if(iStateAwareSession.State().MainState() != ESsmNormal && err == KErrNone)

		{

		iStateAwareSession.RequestStateNotification(iStatus);

		SetActive();

		}

	return err;

	}

void CVwsStartupAware::RunL()

	{

	if (iStatus == KErrNone)

		{

		if (iStateAwareSession.State().MainState() == ESsmNormal)

			{

		iServer.HandleInitializationFinished(); //Bootup is complete now, allowing Viewsrv 11 panics to occur here onwards

			delete this;

			}

		else

			{

			iStateAwareSession.AcknowledgeAndRequestStateNotification(KErrNone, iStatus);

			SetActive();

			}

		}

	}

void CVwsStartupAware::DoCancel()

	{

	iStateAwareSession.RequestStateNotificationCancel();

	}

void CVwsServer::PanicClient(TInt aPanic) const

	{

	 _LIT(KVwsSrvPanic, "ViewSrv");

 	 User::Panic(KVwsSrvPanic,aPanic); 

	}

void CVwsServer::SetSystemDefaultViewL(TInt aMode,const TVwsViewId& aViewId)

	{

	__ASSERT_DEBUG(aMode>=0,PanicClient(EVwsInvalidScreenMode));

	const TInt count = iSystemDefaultViewIdArray.Count();

	if ((aMode>count) || (aMode<0))

		{

		PanicClient(EVwsInvalidScreenMode);	

		}

	else if (aMode < count)

		{

		iSystemDefaultViewIdArray.At(aMode) = aViewId;

		}

	else if (aMode == count) 

		{

		iSystemDefaultViewIdArray.AppendL(aViewId);

		}

	}

void CVwsServer::SetClientRequestTimeOut(const TTimeIntervalMicroSeconds32& aDuration)

	{

	iClientRequestTimeOut=aDuration;

	}

void CVwsServer::SetServerEventTimeOut(const TTimeIntervalMicroSeconds32& aDuration)

	{

	iServerEventTimeOut=aDuration;

	}

void CVwsServer::EnableServerEventTimeOut(TBool aEnable)

	{

	if (!aEnable)

		{

		iIsServerEventTimeOutDisabled++;

		}

	else if (iIsServerEventTimeOutDisabled)

		{

		iIsServerEventTimeOutDisabled--;

		}

	}

void CVwsServer::EnableServerBlankScreen(TBool aEnable)

	{

	iEnableServerBlankScreen = aEnable;	

	}

void CVwsServer::GetSystemDefaultView(TVwsViewId& aViewId)

	{

	TInt mode=iWServSessionHandler->GetScreenMode();

	aViewId = (mode>=0 && mode<iSystemDefaultViewIdArray.Count()) ? iSystemDefaultViewIdArray[mode] : KNullViewId;

	}

TInt CVwsServer::ScreenMode()

	{

	return iWServSessionHandler->GetScreenMode();

	}

TBool CVwsServer::IsSystemDefaultView(const TVwsViewId& aViewId)

	{

	TBool ret=EFalse;

	const TInt numViews=iSystemDefaultViewIdArray.Count();

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

		{

		if (iSystemDefaultViewIdArray[ii] == aViewId)

			{

			return ETrue;

			}

		}

	return ret;

	}

/**

 * Activates the view identified by aViewId. Immediately takes ownership of the message aClientMessage.

 */

void CVwsServer::ActivateViewL(const TVwsViewId& aViewId,CVwsClientMessage* aClientMessage,const RMessage2& aMessage,const TThreadId& aClientThreadId,TVwsCompleteRequest aCompleteRequest)

	{

	TVwsViewId viewId=aViewId;

	if (viewId==KNullViewId)

		{

		GetSystemDefaultView(viewId);

		}

	CleanupStack::PushL(aClientMessage);

	CVwsThreadWatcher* threadWatcher=new(ELeave) CVwsThreadWatcher();

	CleanupStack::PushL(threadWatcher);

	CVwsEventTimer* eventTimer=CVwsEventTimer::NewLC(iClientRequestTimeOut,iServerEventTimeOut);

	RThread threadOfClientInitiatingViewSwitch;

	User::LeaveIfError(aMessage.Client(threadOfClientInitiatingViewSwitch));

	CleanupClosePushL(threadOfClientInitiatingViewSwitch);	

	CVwsServerEvent* activationEvent=new(ELeave) CVwsServerEvent_Activate(*this,CVwsServerEvent::ENormal,*iEventQueue,viewId,aClientMessage,aMessage,aClientThreadId,aCompleteRequest,threadWatcher,eventTimer,threadOfClientInitiatingViewSwitch);

	CleanupStack::Pop(4, aClientMessage); // the CVwsServerEvent_Activate object is now the owner of aClientMessage, threadWatcher, eventTimer and threadOfClientInitiatingViewSwitch

	iEventQueue->ProcessEventL(activationEvent);

#ifdef __DO_LOGGING__

	iNoActivationRequests++;

	LOG3(CVwsLog::ELoud,_L("Cumulative activation requests since server start - %d"),iNoActivationRequests);

#endif

	}

void CVwsServer::ActivateViewL(const TVwsViewId& aViewId,CVwsClientMessage* aClientMessage,const RMessage2& aMessage,const CVwsSession& aSession,TVwsCompleteRequest aCompleteRequest)

	{

	ActivateViewL(aViewId,aClientMessage,aMessage,aSession.ClientThreadId(),aCompleteRequest);

	}

TVwsViewId CVwsServer::ActiveView()

	{

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->HasActiveView())

			{

			return thisSession->ActiveView();

			}

		}

	return KNullViewId;

	}

void CVwsServer::SetActiveView(const TThreadId& aThreadId,const TVwsViewId& aViewId)

	{

#ifdef _DEBUG

	TVwsViewId activeView=ActiveView();

	if (activeView != KNullViewId)

		{

		LOG6(CVwsLog::EQuiet,_L("Changing active view to \"%x,%x\" [previously \"%x,%x\"]"),aViewId.iAppUid.iUid,aViewId.iViewUid.iUid,activeView.iAppUid.iUid,activeView.iViewUid.iUid);

		}

	else

		{

		LOG4(CVwsLog::EQuiet,_L("Changing active view to \"%x,%x\" [no view previously active]"),aViewId.iAppUid.iUid,aViewId.iViewUid.iUid);

		}

#endif

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->ClientThreadId()==aThreadId)

			{

			thisSession->SetActiveView(aViewId);

			}

		else if (thisSession->HasActiveView())

			{

			thisSession->ClearActiveView();

			}

		}

	}

void CVwsServer::ClearActiveView()

	{

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->HasActiveView())

			{

			thisSession->ClearActiveView();

			break;

			}

		}

	}

void CVwsServer::SetViewAdditionObserver(MVwsViewAdditionObserver* aViewAdditionObserver)

	{

	ASSERT((iViewAdditionObserver==NULL) || (aViewAdditionObserver==NULL));

	iViewAdditionObserver=aViewAdditionObserver;

	}

void CVwsServer::HandleScreenDeviceChangedL()

	{

	LOG2(CVwsLog::ENormal,_L("Received screen device changed notification from WServ, creating event to handle it"));

	CVwsThreadWatcher* threadWatcher=new(ELeave) CVwsThreadWatcher();

	CleanupStack::PushL(threadWatcher);

	CVwsEventTimer* eventTimer=CVwsEventTimer::NewLC(iClientRequestTimeOut,iServerEventTimeOut);

	CVwsServerEvent* screenDeviceChangedEvent=new(ELeave) CVwsServerEvent_ScreenDeviceChanged(*this,*iEventQueue,threadWatcher,eventTimer);

	CleanupStack::Pop(2); // threadWatcher, eventTimer - _ScreenDeviceChanged event is now the owner.

	iEventQueue->ProcessEventL(screenDeviceChangedEvent);

	}

TInt CVwsServer::StartApp(const TUid& aAppUid,TThreadId& aThreadId)

	{

	LOG3(CVwsLog::ENormal,_L("Attempting to start app \"%x\""),aAppUid.iUid);

	TRAPD(err,iAppStarter.StartAppL(aAppUid,aThreadId));

	return err;

	}

TInt CVwsServer::CheckViewExists(const TThreadId& aThreadId,const TVwsViewId& aViewId)

	{

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->ClientThreadId()==aThreadId)

			{

			return thisSession->CheckViewExists(aViewId);

			}

		}

	return KErrNotFound;

	}

CVwsSession* CVwsServer::ActiveViewSession()

	{

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->HasActiveView())

			{

			return thisSession;

			}

		}

	return NULL;

	}

CVwsSession* CVwsServer::SessionByUid(const TUid& aAppUid)

	{

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->AppUid()==aAppUid && !thisSession->Protected())

			{

			return thisSession;

			}

		}

	return NULL;

	}

CVwsSession* CVwsServer::SessionByThreadIdAndAppUid(const TThreadId& aThreadId,const TUid& aAppUid)

	{

	for (iSessionIter.SetToFirst();iSessionIter;iSessionIter++)

		{

		CSession2* baseSession=iSessionIter;

		CVwsSession* thisSession=STATIC_CAST(CVwsSession*,baseSession);

		if (thisSession->ClientThreadId()==aThreadId && thisSession->AppUid()==aAppUid)

			{

			return thisSession;

			}

		}

	return NULL;

	}

CVwsSession* CVwsServer::SessionByThreadId(const TThreadId& aThreadId)

	{