1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/nga/SERVER/openwfc/WSTOP.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1187 @@
1.4 +// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// Top level window server code
1.18 +//
1.19 +//
1.20 +
1.21 +#include "wstop.h"
1.22 +
1.23 +#include <hal.h>
1.24 +#include <graphics/fbsdefs.h>
1.25 +#include "W32STD.H"
1.26 +#include "ANIM.H"
1.27 +#include "gc.h"
1.28 +#include "playbackgc.h"
1.29 +#include "rootwin.h"
1.30 +#include "windowgroup.h"
1.31 +#include "EVENT.H"
1.32 +#include "KEYCLICK.H"
1.33 +#include "panics.h"
1.34 +#include "inifile.h"
1.35 +#include "pointer.h"
1.36 +#include "WSGRAPHICDRAWERFACTORY.H"
1.37 +#include "redrawmsgwindow.h"
1.38 +#include <graphics/WSGRAPHICDRAWERINTERFACE.H>
1.39 +#include "WsMemMgr.h"
1.40 +#include "backedupwindow.h"
1.41 +#include "wsfont.h"
1.42 +#include "registeredsurfacemap.h"
1.43 +#include <EGL/egl.h>
1.44 +
1.45 +#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP
1.46 +#include <e32power.h>
1.47 +#endif
1.48 +
1.49 +#include "registeredsurfacemap.h"
1.50 +#include "windowelementset.h"
1.51 +#include "wspluginmanager.h"
1.52 +#include "renderorientationtracker.h"
1.53 +
1.54 +// IDs of p&s properties that optionally contain callbacks that may be used
1.55 +// to release singletons owned by libraries at shutdown in order to make
1.56 +// the memory leak tests work.
1.57 +// By convention, the ID is the same as the UID3 of the libary.
1.58 +static TBool gReleaseSingletonsOnExit = EFalse;
1.59 +static const TUid KOpenWfcImplCleanupKey = {0x10286FC4};
1.60 +static const TUid KOpenWfcInteropCleanupKey = {0x10286FC5};
1.61 +
1.62 +typedef CDebugLogBase *(*CreateDebugLog)(TBool aIsFirst, TDesC &aParams);
1.63 +
1.64 +CWsActiveScheduler* CWsActiveScheduler::Static()
1.65 + {
1.66 + return static_cast<CWsActiveScheduler*>(CActiveScheduler::Current());
1.67 + }
1.68 +
1.69 +CWsActiveScheduler::CWsActiveScheduler(): iNumSamples(100)
1.70 + {
1.71 + iRun = User::FastCounter();
1.72 + if((KErrNone == HAL::Get(HALData::EFastCounterFrequency,iFastCounterFreq)) && iFastCounterFreq)
1.73 + {
1.74 + iData = reinterpret_cast<TSample*>(User::AllocZ(sizeof(TSample)*iNumSamples));
1.75 + }
1.76 + }
1.77 +
1.78 +CWsActiveScheduler::~CWsActiveScheduler()
1.79 + {
1.80 + User::FreeZ(reinterpret_cast<void*&>(iData));
1.81 + }
1.82 +void CWsActiveScheduler::PrepareDraw()
1.83 + {
1.84 + iRunDraw = User::FastCounter();
1.85 + }
1.86 +
1.87 +void CWsActiveScheduler::CancelPrepare()
1.88 + {
1.89 + }
1.90 +
1.91 +void CWsActiveScheduler::StartDraw()
1.92 + {
1.93 + TTime now;
1.94 + now.UniversalTime();
1.95 + TUint64 duration = now.MicroSecondsFrom(iRunDraw).Int64();
1.96 + iPreparing += duration;
1.97 + iRunDraw = now;
1.98 + if(iData)
1.99 + {
1.100 + iData[iCurrent].iStart = iRunDraw;
1.101 + }
1.102 + iDraws++;
1.103 + }
1.104 +
1.105 +void CWsActiveScheduler::DrawStats(TInt& aUpdatesPerSecond,TInt64& aPixelsPerSecond,TInt aWindowInSeconds) const
1.106 + {
1.107 + aUpdatesPerSecond = 0;
1.108 + aPixelsPerSecond = 0;
1.109 + if(iData)
1.110 + {
1.111 + // work out statistic
1.112 + TTime window;
1.113 + window.UniversalTime();
1.114 + window -= TTimeIntervalSeconds(aWindowInSeconds);
1.115 + TUint32 pixels = 0;
1.116 + TInt64 duration = 0;
1.117 + for(TUint i=0; i<iNumSamples; i++)
1.118 + {
1.119 + if(iData[i].iStart >= window)
1.120 + {
1.121 + pixels += iData[i].iPixels;
1.122 + duration += iData[i].iDuration;
1.123 + aUpdatesPerSecond++;
1.124 + }
1.125 + }
1.126 + if(aUpdatesPerSecond && duration)
1.127 + {
1.128 + const TReal pixelsPerMicroSecond = (static_cast<TReal>(pixels) / static_cast<TReal>(duration));
1.129 + aPixelsPerSecond = static_cast<TInt64>(pixelsPerMicroSecond * 1000000.0);
1.130 + aUpdatesPerSecond /= aWindowInSeconds;
1.131 + }
1.132 + }
1.133 + }
1.134 +
1.135 +void CWsActiveScheduler::StopDraw(TInt aPixelsUpdated)
1.136 + {
1.137 + TTime now;
1.138 + now.UniversalTime();
1.139 + TUint32 duration = now.MicroSecondsFrom(iRunDraw).Int64();
1.140 + // do recording
1.141 + if(iData)
1.142 + {
1.143 + iData[iCurrent].iDuration = now.MicroSecondsFrom(iData[iCurrent].iStart).Int64();
1.144 + iData[iCurrent].iPixels = aPixelsUpdated;
1.145 + if(++iCurrent >= iNumSamples)
1.146 + {
1.147 + iCurrent = 0;
1.148 + }
1.149 + }
1.150 + iDrawing += duration;
1.151 + }
1.152 +
1.153 +void CWsActiveScheduler::WaitForAnyRequest()
1.154 + {
1.155 + TTime stop;
1.156 + stop.UniversalTime();
1.157 + iTotal += stop.MicroSecondsFrom(iRun).Int64();
1.158 + CActiveScheduler::WaitForAnyRequest();
1.159 + iRequests++;
1.160 + iRun.UniversalTime();
1.161 + iIdle += iRun.MicroSecondsFrom(stop).Int64();
1.162 + }
1.163 +
1.164 +
1.165 +void CWsActiveScheduler::Error(TInt /*aError*/) const
1.166 + {
1.167 + iErrors++;
1.168 + }
1.169 +
1.170 +void CWsActiveScheduler::AccumReclaimedIdleTime(TInt64 aMicroSeconds)
1.171 + {
1.172 + iReclaimedIdleTime += aMicroSeconds;
1.173 + }
1.174 +
1.175 +
1.176 +GLREF_C void StateDump(CWsRootWindow* aRootWindow);
1.177 +GLREF_C void HeapDump();
1.178 +
1.179 +// Static objects that need to be destroyed on exit
1.180 +GLDEF_D CDebugLogBase *wsDebugLog=NULL;
1.181 +GLDEF_D TInt wsDebugLogLevel=0;
1.182 +GLDEF_D CIniFile *WsIniFile=NULL;
1.183 +//
1.184 +GLDEF_D TPtr nullDescriptor(NULL,0);
1.185 +
1.186 +LOCAL_D CWsActiveScheduler *TheActiveScheduler;
1.187 +
1.188 +CScreen* CWsTop::iCurrentFocusScreen;
1.189 +CArrayPtrFlat<CScreen>* CWsTop::iScreens ;
1.190 +TInt CWsTop::iNumberOfScreens ;
1.191 +CWsTop::CShellStarter* CWsTop::iShellStarter;
1.192 +
1.193 +CWsPluginManager *CWsTop::iPluginManager;
1.194 +CWindowServer *CWsTop::iServer;
1.195 +RLibrary CWsTop::iDebugLib;
1.196 +CWsShellLogon *CWsTop::iShell;
1.197 +const CWsClient *CWsTop::iShellClient;
1.198 +TBool CWsTop::iPreviousShellClient=EFalse;
1.199 +TInt CWsTop::iShellBootMode;
1.200 +TBool CWsTop::iShuttingDown;
1.201 +TBool CWsTop::iIsFirstLog=ETrue;
1.202 +CWsWindowBase *CWsTop::iWindowToSendOffEventsTo=NULL;
1.203 +RTimer CWsTop::iTimer;
1.204 +TBool CWsTop::iIgnoreSwitchOffEvent=EFalse;
1.205 +TBool CWsTop::iFadeEnabled=ETrue;
1.206 +TBool CWsTop::iFinishEveryFlush=EFalse;
1.207 +TBool CWsTop::iMultiFocusPolicy=EFalse;
1.208 +#if defined(__WINS__)
1.209 +TFullName WsSemName;
1.210 +#endif
1.211 +const CWsClient* CWsTop::iTriggerHeapCheckOnClientExit=NULL;
1.212 +TWsCheckHeapOnDisconnectMode CWsTop::iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;
1.213 +TInt CWsTop::iCheckHeapResult=KErrNotReady;
1.214 +TBool CWsTop::iDoHeapCheckAndRestart=EFalse;
1.215 +#define RFbsSession_SendCommand_ShutDownMessage 1 // A FBS message that is not published yet and probably never will be.
1.216 +CWsRenderOrienationTracker* CWsTop::iRenderOrientationTracker=NULL;
1.217 +
1.218 +static void DefineSingletonKey(const TUid& aSingletonKey)
1.219 +/**
1.220 + * Defines a new property for a singleton key. WServ must only process
1.221 + * singleton keys that it created to prevent a malicious process with the
1.222 + * WriteDeviceData capability causing arbitrary functions to be executed.
1.223 + *
1.224 + * @param aSingeltonKey The UID of the singleton key to define.
1.225 + */
1.226 + {
1.227 + RThread t;
1.228 + TUid category = { t.SecureId().iId };
1.229 + RProperty prop;
1.230 +
1.231 + // Write access is restricted to THIS process
1.232 + TInt err = prop.Define( category, aSingletonKey.iUid,
1.233 + RProperty::EByteArray, TSecurityPolicy( t.SecureId() ),
1.234 + TSecurityPolicy( t.SecureId() ), sizeof( TCallBack ) );
1.235 +
1.236 + if ( err == KErrNone )
1.237 + {
1.238 + TCallBack cb( NULL, NULL );
1.239 + TPckgC<TCallBack> cbPckg( cb );
1.240 +
1.241 + // Any error should cause the properties to be ignored
1.242 + err = prop.Set( category, aSingletonKey.iUid, cbPckg );
1.243 + }
1.244 +
1.245 + if ( err != KErrNone )
1.246 + {
1.247 + // A problem occured / the property already existed so for safety
1.248 + // the release code should be skipped.
1.249 + gReleaseSingletonsOnExit = EFalse;
1.250 + }
1.251 +
1.252 + prop.Close();
1.253 + t.Close();
1.254 + }
1.255 +
1.256 +static void DeleteSingleton( const TUid& aSingletonKey )
1.257 +/**
1.258 + * Deletes a singleton object that was created on WServ's main heap.
1.259 + *
1.260 + * @pre The ws plugins have not been unloaded.
1.261 + * @param aSingletonKey The UID of the singleton which correponds to an
1.262 + * RProperty within WServ's category.
1.263 + */
1.264 + {
1.265 + if ( gReleaseSingletonsOnExit )
1.266 + {
1.267 + RThread t;
1.268 + TPckgBuf<TCallBack> cb;
1.269 + RProperty prop;
1.270 + TInt err = prop.Get(TUid::Uid(t.SecureId().iId), aSingletonKey.iUid, cb);
1.271 + if (err == KErrNone && cb.Length() == sizeof(TCallBack) &&
1.272 + cb().iFunction && cb().iPtr == &User::Heap())
1.273 + {
1.274 + // Callback is only invoked if the heap for the singleton was the
1.275 + // WServ heap because the WServ memory leak tests only check this
1.276 + // heap.
1.277 + cb().CallBack();
1.278 + }
1.279 + // Errors are ignored because the purpose of this function is to free
1.280 + // singletons in order top make memory leak checks pass.
1.281 + prop.Close();
1.282 + t.Close();
1.283 + }
1.284 + }
1.285 +
1.286 +void CWsTop::DeleteStaticsL()
1.287 + {
1.288 + iShuttingDown=ETrue;
1.289 + delete iRenderOrientationTracker;
1.290 +
1.291 + CClick::DeleteStatics();
1.292 + TWsPointer::Stop();
1.293 + CWsClient::DeleteStatics();
1.294 +//
1.295 + delete iShellStarter;
1.296 + iServer->DestroySessionsForShutdown();
1.297 +
1.298 + CWsBackedUpWindow::StaticDestroy();
1.299 + delete iShell;
1.300 + DisableLogging();
1.301 +
1.302 + CEventQueue::DeleteStaticsL();
1.303 +
1.304 + CWsSpriteBase::DeleteStatics();
1.305 + CWsGc::DeleteStatics();
1.306 + CPlaybackGc::DeleteStatics();
1.307 + CWsAnimDll::DeleteStatics();
1.308 + CWsFontCache::DestroyInstance();
1.309 +
1.310 + iScreens->ResetAndDestroy();
1.311 + delete iScreens;
1.312 +
1.313 + delete iServer;
1.314 + TWindowServerEvent::DeleteStatics();
1.315 +
1.316 + // Free singletons on WServ heap created by libraries. Must be called
1.317 + // BEFORE iPluginManager is deleted otherwise the library code could have
1.318 + // been unloaded.
1.319 + DeleteSingleton(KOpenWfcImplCleanupKey);
1.320 + DeleteSingleton(KOpenWfcInteropCleanupKey);
1.321 + eglReleaseThread();
1.322 +
1.323 + if (!iDoHeapCheckAndRestart)
1.324 + {
1.325 + RFbsSession::GetSession()->SendCommand(RFbsSession_SendCommand_ShutDownMessage); //This line is just being tidy, never really does anything useful.
1.326 + }
1.327 +
1.328 + RFbsSession::Disconnect();
1.329 + iDebugLib.Close();
1.330 + iTimer.Close();
1.331 + TWsPointer::DeleteStatics();
1.332 + delete TheActiveScheduler;
1.333 +
1.334 + // iPluginManager is not created in InitStaticsL because plugins need to be loaded
1.335 + // before E32Main's loop for EcomSession allocations issues
1.336 + delete iPluginManager;
1.337 + }
1.338 +
1.339 +RWsTextCursor *CWsTop::CurrentTextCursor()
1.340 + {
1.341 + if(iCurrentFocusScreen && FocusWindowGroup())
1.342 + {
1.343 + return FocusWindowGroup()->TextCursor();
1.344 + }
1.345 + else
1.346 + {
1.347 + return NULL;
1.348 + }
1.349 + }
1.350 +
1.351 +CWsClient *CWsTop::FocusWindowGroupOwner()
1.352 + {
1.353 + return(FocusWindowGroup() ? FocusWindowGroup()->WsOwner():NULL);
1.354 + }
1.355 +
1.356 +void CWsTop::ClientDestroyed(const CWsClient *aClient)
1.357 + {
1.358 + if (aClient==iShellClient)
1.359 + iShellClient=NULL;
1.360 + }
1.361 +
1.362 +void CWsTop::NewSession(const CWsClient *aClient)
1.363 + {
1.364 + if (iShellClient==NULL && iShell)
1.365 + {
1.366 +#if defined(__WINS__)
1.367 + RThread proc;
1.368 + proc=aClient->Client();
1.369 +#else
1.370 + RProcess proc;
1.371 + aClient->Client().Process(proc);
1.372 +#endif
1.373 + TFullName procName = proc.FullName();
1.374 + // Before comparing the proc name with iShell name , truncate the proc name up to the actual name
1.375 + // referring to the process, by removing the part which starts with ':', if exists.
1.376 + TInt colonLocation = procName.Locate(':');
1.377 + if( KErrNotFound != colonLocation)
1.378 + {
1.379 + procName = procName.Left(colonLocation);
1.380 + }
1.381 + if (procName ==iShell->FullName())
1.382 + {
1.383 + iShellClient=aClient;
1.384 + if (!iPreviousShellClient)
1.385 + {
1.386 + iPreviousShellClient=ETrue;
1.387 + aClient->Screen()->RootWindow()->SetColorIfClear();
1.388 + }
1.389 + }
1.390 +#if !defined(__WINS__)
1.391 + proc.Close();
1.392 +#endif
1.393 + }
1.394 + }
1.395 +
1.396 +void CWsTop::SessionExited(CWsClient *aClient)
1.397 + {
1.398 + if (iShuttingDown)
1.399 + {
1.400 + RProcess proc;
1.401 + TInt err=aClient->Client().Process(proc);
1.402 + if (err==KErrNone && proc.Id()!=RProcess().Id())
1.403 + proc.Kill(0);
1.404 + else
1.405 + const_cast<RThread&>(aClient->Client()).Kill(0);
1.406 + if (err==KErrNone)
1.407 + proc.Close();
1.408 + }
1.409 + else if (iHeapCheckMode!=EWsCheckHeapOnDisconnectModeNone && aClient==iTriggerHeapCheckOnClientExit)
1.410 + {
1.411 + if (iHeapCheckMode==EWsCheckHeapOnDisconnectModeOnce)
1.412 + {
1.413 + iHeapCheckMode=EWsCheckHeapOnDisconnectModeNone;
1.414 + }
1.415 + iTriggerHeapCheckOnClientExit=NULL;
1.416 + iDoHeapCheckAndRestart=ETrue;
1.417 + Exit();
1.418 + }
1.419 + if (iServer->SessionCount()==1 && iShellBootMode==EShellBootModeNoReboot && iShell==NULL)
1.420 + StartShell();
1.421 + }
1.422 +
1.423 +
1.424 +void CWsTop::RunServerL()
1.425 + {
1.426 + InitStaticsL();
1.427 + CWsMemoryManager* memMgr = CWsMemoryManager::NewLC();
1.428 + CActiveScheduler::Start();
1.429 + CleanupStack::PopAndDestroy(memMgr);
1.430 + DeleteStaticsL();
1.431 + }
1.432 +
1.433 +void CWsTop::InitStaticsL()
1.434 + {
1.435 + iShuttingDown=EFalse;
1.436 + // By default shell should be started.
1.437 + TBool startShell = ETrue;
1.438 +
1.439 + iCurrentFocusScreen = 0;
1.440 +
1.441 + // The windows server has been invoked.
1.442 + // This may have been from the system starter (via a
1.443 + // start up rss file)
1.444 + // This block looks for a "-NoShell" argument in the invocation.
1.445 + // The existence of the argument means that shell does not need to be
1.446 + // invoked from here because the new system starter
1.447 + // is in charge, and it will do it if required.
1.448 +
1.449 + _LIT(KNoShell,"-NOSHELL");
1.450 +
1.451 + TInt argLen = User::CommandLineLength();
1.452 + if(argLen)
1.453 + {
1.454 + HBufC* arg = HBufC::NewLC(argLen);
1.455 + TPtr argPtr = arg->Des();
1.456 + User::CommandLine(argPtr);
1.457 + argPtr.UpperCase();
1.458 +
1.459 + if(KErrNotFound != argPtr.Find(KNoShell))
1.460 + {
1.461 + // Don't start the shell. It will be started if required by
1.462 + // the system starter.
1.463 + startShell = EFalse;
1.464 + }
1.465 + CleanupStack::PopAndDestroy(arg);
1.466 + }
1.467 +
1.468 + TheActiveScheduler=new(ELeave) CWsActiveScheduler;
1.469 + CActiveScheduler::Install(TheActiveScheduler);
1.470 + // WsIniFile is already created (before E32Main's Loop)
1.471 + _LIT(KWSERVIniFileVarLogEnable,"LOGENABLE");
1.472 + TInt loggingLevel;
1.473 + if (WsIniFile->FindVar(KWSERVIniFileVarLogEnable,loggingLevel))
1.474 + {
1.475 + EnableLogging(EDoNotReloadWsIni);
1.476 + if (wsDebugLog)
1.477 + {
1.478 + wsDebugLog->SetLoggingLevel(loggingLevel);
1.479 + }
1.480 + }
1.481 +
1.482 + _LIT(KWSERVIniFileVarFadeEnable,"FADEDISABLE");
1.483 + iFadeEnabled = !WsIniFile->FindVar(KWSERVIniFileVarFadeEnable);
1.484 +
1.485 + _LIT(KWSERVIniFileVarFinishEveryFlush,"FINISHEVERYFLUSH");
1.486 + iFinishEveryFlush = WsIniFile->FindVar(KWSERVIniFileVarFinishEveryFlush);
1.487 +
1.488 + _LIT(KWSERVIniFileVarSwitchOffEvent,"IGNORESWITCHOFFEVENT");
1.489 + iIgnoreSwitchOffEvent = WsIniFile->FindVar(KWSERVIniFileVarSwitchOffEvent);
1.490 +
1.491 + iPluginManager = CWsPluginManager::NewL(); // need to be constructed before iServer!
1.492 + iServer=CWindowServer::NewL();
1.493 + CClick::InitStaticsL();
1.494 +
1.495 + RProcess wservProc;
1.496 + if (!wservProc.DefaultDataPaged())
1.497 + {
1.498 + iServer->SetPinClientDescriptors(ETrue);
1.499 + }
1.500 + User::LeaveIfError(FbsStartup());
1.501 + User::LeaveIfError(RFbsSession::Connect());
1.502 + User::LeaveIfError(iTimer.CreateLocal());
1.503 +
1.504 + TWindowServerEvent::InitStaticsL();
1.505 + CWsClient::InitStaticsL();
1.506 + //-------------------------------------------
1.507 + User::LeaveIfError( HAL::Get( HAL::EDisplayNumberOfScreens, iNumberOfScreens ) ) ;
1.508 + // Check that the INI file matches the HAL
1.509 + WS_ASSERT_ALWAYS(WsIniFile->NumberOfScreens()<=iNumberOfScreens, EWsPanicScreenInformationError);
1.510 +
1.511 + iScreens = new (ELeave) CArrayPtrFlat<CScreen>( iNumberOfScreens ) ; //
1.512 + // now construct screens for as long as there is information
1.513 +
1.514 + TInt ii ;
1.515 + for ( ii = 0 ; ii < iNumberOfScreens ; ++ii )
1.516 + {
1.517 + InitScreenL( ii ) ;
1.518 + }
1.519 + //---------------------------------------------
1.520 + iCurrentFocusScreen = (*iScreens)[0] ;
1.521 + iServer->StartL();
1.522 +
1.523 + CWsFontCache::CreateInstanceL();
1.524 + CWsGc::InitStaticsL();
1.525 + CPlaybackGc::InitStaticsL();
1.526 + CWsSpriteBase::InitStaticsL();
1.527 + CEventQueue::InitStaticsL();
1.528 +
1.529 +//
1.530 + CWsAnimDll::InitStaticsL();
1.531 +//
1.532 + TInt bootMode=0;
1.533 + _LIT(KWSERVIniFileVarReboot,"REBOOT");
1.534 + WsIniFile->FindVar(KWSERVIniFileVarReboot,bootMode);
1.535 + if (bootMode>=0 && bootMode<=2)
1.536 + iShellBootMode=bootMode;
1.537 +//
1.538 + CWsBackedUpWindow::StaticInitL();
1.539 + CWsRedrawMsgWindow::StaticInitL();
1.540 +//
1.541 + TWsPointer::InitStaticsL();
1.542 + iShellStarter=new (ELeave) CShellStarter;
1.543 + iShellStarter->ConstructL();
1.544 + _LIT(KPreProcess,"REMOVEFADINGONFOCUSGAIN");
1.545 + CWsWindowGroup::SetFocusGainPreprocessing(WsIniFile->FindVar(KPreProcess));
1.546 + _LIT(KAbsFade,"ABSOLUTEFADING");
1.547 + CWsClientWindow::SetAbsoluteFading(WsIniFile->FindVar(KAbsFade));
1.548 +
1.549 +//Set the focus policy
1.550 + _LIT(KFocusPolicy,"MULTIFOCUSPOLICY");
1.551 + if(WsIniFile->FindVar(KFocusPolicy))
1.552 + {
1.553 + iMultiFocusPolicy = ETrue;
1.554 + }
1.555 + RProcess::Rendezvous(KErrNone);
1.556 + // Start the shell from here unless the 'NoShell' option has been
1.557 + // received indicating that the system starter will start the shell directly.
1.558 + if(startShell)
1.559 + {
1.560 + StartShell();
1.561 + }
1.562 + UserSvr::WsRegisterSwitchOnScreenHandling(ETrue);
1.563 +
1.564 + iRenderOrientationTracker = CWsRenderOrienationTracker::NewL();
1.565 + }
1.566 +
1.567 +
1.568 +void CWsTop::InitScreenL( TInt aScreenNumber) // static
1.569 + {
1.570 + // create a new screen, read ini file for aScreenNumber (this happens in CScreen - just need to pass a screen number from here
1.571 + CScreen* screen = new (ELeave) CScreen() ;
1.572 + CleanupStack::PushL( screen ) ;
1.573 + TRect digitiserArea;
1.574 + if (aScreenNumber==0)
1.575 + {
1.576 + TMachineInfoV1Buf machineBuf;
1.577 + UserHal::MachineInfo(machineBuf);
1.578 + TMachineInfoV1& machineInfo=*(TMachineInfoV1*)machineBuf.Ptr();
1.579 + digitiserArea = TRect(-machineInfo.iOffsetToDisplayInPixels,machineInfo.iXYInputSizeInPixels);
1.580 + }
1.581 + screen->ConstructL(digitiserArea, aScreenNumber);
1.582 + iScreens->AppendL( screen ) ;
1.583 + CleanupStack::Pop( screen ) ;
1.584 + }
1.585 +
1.586 +void CWsTop::ClearAllRedrawStores()
1.587 + {
1.588 + TInt ii;
1.589 + if (iScreens && iScreens->Count()>=iNumberOfScreens)
1.590 + { //All screens are initialized
1.591 + for (ii=0; ii<iNumberOfScreens; ++ii)
1.592 + {
1.593 + CScreen *screen=(*iScreens)[ii];
1.594 + CWsWindowGroup* group=screen->RootWindow()->Child();
1.595 + while (group!=NULL)
1.596 + {
1.597 + CWsWindowBase* win=group->Child();
1.598 + if (win)
1.599 + {
1.600 + while (win!=group)
1.601 + {
1.602 + static_cast<CWsWindow*>(win)->Redraw()->ClearRedrawStore(ETrue);
1.603 + //On orientation switch, window is no longer present on screen
1.604 + static_cast<CWsWindow*>(win)->SetDrawnToScreen(EFalse);
1.605 + if (win->BaseChild())
1.606 + win=win->BaseChild();
1.607 + else
1.608 + {
1.609 + do
1.610 + {
1.611 + if (win->NextSibling())
1.612 + {
1.613 + win=win->NextSibling();
1.614 + break;
1.615 + }
1.616 + win=win->BaseParent();
1.617 + }
1.618 + while (win!=group);
1.619 + }
1.620 + }
1.621 + }
1.622 + group=group->NextSibling();
1.623 + }
1.624 + TriggerRedraws(screen->RootWindow());
1.625 + }
1.626 + }
1.627 + }
1.628 +
1.629 +void CWsTop::Exit()
1.630 + {
1.631 + CActiveScheduler::Stop();
1.632 + }
1.633 +
1.634 +void CWsTop::TriggerRedraws(CWsRootWindow* aRootWindow)
1.635 + {
1.636 + for(CWsWindowGroup *group=aRootWindow->Child();group!=NULL;group=group->NextSibling())
1.637 + group->WsOwner()->TriggerRedraw();
1.638 + }
1.639 +
1.640 +void CWsTop::StartShell()
1.641 + {
1.642 + TRAPD(err,iShell=new(ELeave) CWsShellLogon());
1.643 + if (err==KErrNone)
1.644 + {
1.645 + RFs fs;
1.646 + if ((err=fs.Connect())==KErrNone)
1.647 + {
1.648 + fs.SetNotifyUser(EFalse);
1.649 + TRAP(err,iShell->ConstructL(fs));
1.650 + fs.Close();
1.651 + }
1.652 + }
1.653 + if (err!=KErrNone)
1.654 + {
1.655 +#ifdef _DEBUG
1.656 + RDebug::Print(_L("Failed to start shell: err=%d\n"),err);
1.657 +#endif
1.658 + delete iShell;
1.659 + iShell=NULL;
1.660 + iShellStarter->After(TTimeIntervalMicroSeconds32(1000000));
1.661 + }
1.662 + }
1.663 +
1.664 +void CWsTop::ShellExited()
1.665 + {
1.666 + delete iShell;
1.667 + iShell=NULL;
1.668 + switch(iShellBootMode)
1.669 + {
1.670 + case EShellBootModeReboot:
1.671 + StartShell();
1.672 + break;
1.673 + case EShellBootModeNoReboot:
1.674 + if (iServer->SessionCount()==0)
1.675 + StartShell();
1.676 + break;
1.677 + case EShellBootModeExit:
1.678 + Exit();
1.679 + break;
1.680 + }
1.681 + }
1.682 +
1.683 +TInt CWsTop::SetSendOffEventsToShell(CWsClient *aClient,const TWsClCmdOffEventsToShell &aData)
1.684 + {
1.685 + CWsWindowBase *window=NULL;
1.686 + if (aData.window==0)
1.687 + {
1.688 + if (aData.on)
1.689 + aClient->PPanic(EWservPanicNoWindowSpecifed);
1.690 + }
1.691 + else
1.692 + aClient->HandleToWindow(aData.window,&window);
1.693 + if (aData.on)
1.694 + {
1.695 + if (iWindowToSendOffEventsTo!=NULL && aClient!=iShellClient) //Allow the shell to pinch it
1.696 + return KErrAlreadyExists;
1.697 + iWindowToSendOffEventsTo=window;
1.698 + }
1.699 + else
1.700 + {
1.701 + if (iWindowToSendOffEventsTo==window || (!window && aClient==iWindowToSendOffEventsTo->WsOwner()))
1.702 + iWindowToSendOffEventsTo=NULL;
1.703 + }
1.704 + return KErrNone;
1.705 + }
1.706 +
1.707 +void CWsTop::StopWindowGettingOffEvents(CWsWindowBase* aWindow)
1.708 + {
1.709 + if (aWindow==iWindowToSendOffEventsTo)
1.710 + iWindowToSendOffEventsTo=NULL;
1.711 + }
1.712 +
1.713 +/** Routes "Off" events to the shutdown manager if one is registered. Othwerwise calls Power API's directly to
1.714 +set the power mode of the device accordingly.
1.715 +@internalTechnology
1.716 +@released
1.717 +@param aEvent Type of event that Wserv passes to client as OFF events.
1.718 +It can be EEventSwitchOff, EEventCaseClosed, EEventKeySwitchOff or EEventRestartSystem.
1.719 +@param aDoSwitchOff ETrue if the switch-off should be performed when no shutdown manager is registered
1.720 +and IGNORESWITCHOFFEVENT is not defined in wsini.ini
1.721 +*/
1.722 +void CWsTop::HandleSwitchOff(TInt aEvent,TBool aDoSwitchOff)
1.723 + {
1.724 + // If any shutdown manager is registered, forward the event to it
1.725 + if (iWindowToSendOffEventsTo && iWindowToSendOffEventsTo->QueueEvent(aEvent))
1.726 + return;
1.727 + // Otherwise, do the shutdown here
1.728 + if(!iIgnoreSwitchOffEvent && aDoSwitchOff)
1.729 + {
1.730 +#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP
1.731 + // if LaF is not registered, restart or shutdown using Power API
1.732 + if (aEvent == EEventRestartSystem) // restart
1.733 + {
1.734 + if (Power::EnableWakeupEvents(EPwRestart) == KErrNone)
1.735 + {
1.736 + // Should reboot/power-cycle the system, so no need to RequestWakeupEventNotification
1.737 + Power::PowerDown();
1.738 + }
1.739 + }
1.740 + else // everything else maps to standby for now
1.741 + {
1.742 + if (Power::EnableWakeupEvents(EPwStandby) == KErrNone)
1.743 + {
1.744 + // Prepare to wake up from standby
1.745 + TRequestStatus s;
1.746 + Power::RequestWakeupEventNotification(s);
1.747 + Power::PowerDown();
1.748 + User::WaitForRequest(s);
1.749 + }
1.750 + }
1.751 +#else
1.752 + UserHal::SwitchOff();
1.753 +#endif
1.754 + }
1.755 + }
1.756 +
1.757 +void CWsTop::RedrawScreens()
1.758 + {
1.759 + // apply to all screens
1.760 + TInt screenNo;
1.761 + for(screenNo=0; screenNo<iNumberOfScreens; ++screenNo)
1.762 + {
1.763 + CScreen* screen = Screen(screenNo);
1.764 + TRegionFix<1> screenArea(TRect(screen->DrawableArea()));
1.765 + }
1.766 + }
1.767 +
1.768 +void CWsTop::EnableLogging(TReloadWsIni aSetting)
1.769 + {
1.770 + TInt errorLoc=0;
1.771 + if (wsDebugLog)
1.772 + {
1.773 + if (wsDebugLogLevel==CDebugLogBase::ELogEverything)
1.774 + {
1.775 + wsDebugLogLevel=CDebugLogBase::ELogImportant;
1.776 + wsDebugLog->SetLoggingLevel(wsDebugLogLevel);
1.777 + return;
1.778 + }
1.779 + DisableLogging();
1.780 + }
1.781 +
1.782 + if(aSetting == EDoReloadWsIni)
1.783 + {
1.784 + CIniFile* temp = NULL;
1.785 + TRAPD(err, temp = CIniFile::NewL());
1.786 + if(err == KErrNone)
1.787 + {
1.788 + //loading successful, replace the previous one
1.789 + delete WsIniFile;
1.790 + WsIniFile = temp;
1.791 + }
1.792 + }
1.793 +
1.794 + TPtrC dlog;
1.795 + _LIT(KWSERVDebugLogFileName,"DLOG");
1.796 + TBuf<KMaxFileName> fname(KWSERVDebugLogFileName);
1.797 + _LIT(KWSERVIniFileVarLog,"LOG");
1.798 + if (WsIniFile->FindVar(KWSERVIniFileVarLog,dlog) && dlog.Length()==2)
1.799 + {
1.800 + fname.Append(dlog);
1.801 + TInt err=iDebugLib.Load(fname);
1.802 + if (err==KErrNone)
1.803 + {
1.804 + TUidType uid=iDebugLib.Type();
1.805 + if (uid[1]!=KWservLoggingDllUid)
1.806 + {
1.807 + err=KErrNotSupported;
1.808 + errorLoc=2;
1.809 + }
1.810 + else
1.811 + {
1.812 + TPtrC params;
1.813 + _LIT(KWSERVIniFileVarLogP,"LOGP");
1.814 + if (!WsIniFile->FindVar(KWSERVIniFileVarLogP,params))
1.815 + params.Set(NULL,0);
1.816 + CreateDebugLog func=(CreateDebugLog)iDebugLib.Lookup(1);
1.817 + if (func!=NULL)
1.818 + {
1.819 + TRAP(err,wsDebugLog=(*func)(iIsFirstLog, params));
1.820 + if (err==KErrNone)
1.821 + {
1.822 + iIsFirstLog=EFalse;
1.823 + wsDebugLogLevel=CDebugLogBase::ELogEverything;
1.824 + }
1.825 + else
1.826 + errorLoc=4;
1.827 + }
1.828 + else
1.829 + errorLoc=3;
1.830 + }
1.831 + }
1.832 + else
1.833 + errorLoc=1;
1.834 + if (iCurrentFocusScreen)
1.835 + {
1.836 + TWindowServerEvent::ProcessErrorMessages(TWsErrorMessage::ELogging,(errorLoc<<8)-err);
1.837 + }
1.838 + }
1.839 + }
1.840 +
1.841 +void CWsTop::DisableLogging()
1.842 + {
1.843 + delete wsDebugLog;
1.844 + wsDebugLog=NULL;
1.845 + iDebugLib.Close();
1.846 + }
1.847 +
1.848 +void CWsTop::LogCommand(RWsSession::TLoggingCommand aCommand)
1.849 + {
1.850 + switch(aCommand)
1.851 + {
1.852 + case RWsSession::ELoggingEnable:
1.853 + EnableLogging();
1.854 + break;
1.855 + case RWsSession::ELoggingDisable:
1.856 + DisableLogging();
1.857 + break;
1.858 + case RWsSession::ELoggingStatusDump:
1.859 + StateDump();
1.860 + break;
1.861 + case RWsSession::ELoggingHeapDump:
1.862 + HeapDump();
1.863 + break;
1.864 + }
1.865 + }
1.866 +
1.867 +void CWsTop::StateDump()
1.868 + {
1.869 + TInt screenNo;
1.870 + for (screenNo=0; screenNo<iNumberOfScreens; ++screenNo)
1.871 + ::StateDump( (*iScreens)[screenNo]->RootWindow());
1.872 + }
1.873 +
1.874 +void CWsTop::SetCurrentFocusScreen(CScreen* aScreen)
1.875 + {
1.876 + iCurrentFocusScreen = aScreen;
1.877 + }
1.878 +
1.879 +TInt CWsTop::SetCurrentFocusScreen(TInt aScreenNo)
1.880 + {
1.881 + CScreen* newFocusScreen=CWsTop::Screen(aScreenNo);
1.882 + if (newFocusScreen==iCurrentFocusScreen)
1.883 + return KErrNone;
1.884 +
1.885 + CWsWindowGroup* newFocusGroup=newFocusScreen->FocusWindowGroup();
1.886 + if (!newFocusGroup)
1.887 + return KErrNotReady;
1.888 +
1.889 + CWsWindowGroup* oldFocusGroup=iCurrentFocusScreen->FocusWindowGroup();
1.890 + if (oldFocusGroup)
1.891 + oldFocusGroup->LostFocus();
1.892 + iCurrentFocusScreen=newFocusScreen;
1.893 + newFocusGroup->ReceivedFocus();
1.894 + TWsPointer::UpdatePointerCursor();
1.895 + TWindowServerEvent::SendFocusChangedEvents();
1.896 + return KErrNone;
1.897 + }
1.898 +
1.899 +void CWsTop::SetCheckHeapOnDisconnectClient(const CWsClient* aClient)
1.900 + {
1.901 + iTriggerHeapCheckOnClientExit=aClient;
1.902 + }
1.903 +
1.904 +void CWsTop::SetCheckHeapOnDisconnectMode(TWsCheckHeapOnDisconnectMode aCheckHeapOnDisconnectMode)
1.905 + {
1.906 + iHeapCheckMode=aCheckHeapOnDisconnectMode;
1.907 + }
1.908 +
1.909 +TBool CWsTop::NeedsHeapCheckAndRestart(TInt aStartHeapCount)
1.910 + {
1.911 + if (!iDoHeapCheckAndRestart)
1.912 + return(EFalse);
1.913 + iDoHeapCheckAndRestart=EFalse;
1.914 + iCheckHeapResult=User::Heap().Count()-aStartHeapCount;
1.915 + if(iCheckHeapResult > 0)
1.916 + {
1.917 + const TUint32 orphanedCell = User::Heap().__DbgMarkEnd(aStartHeapCount);
1.918 + RDebug::Printf("Memory leak detected in wserv. First orphaned cell: 0x%8x", orphanedCell);
1.919 + }
1.920 + return(ETrue);
1.921 + }
1.922 +
1.923 +TInt CWsTop::FetchCheckHeapResult()
1.924 + {
1.925 + TInt ret=iCheckHeapResult;
1.926 + iCheckHeapResult=KErrNotReady;
1.927 + return(ret);
1.928 + }
1.929 +
1.930 +/**
1.931 +This function looks for memory which isn't essential to the correct running of the window server
1.932 +and frees some of it.
1.933 +Returns true if some memory was freed, and false if it was unable to free anything.
1.934 +Called from the memory manager in low memory conditions.
1.935 +*/
1.936 +TBool CWsTop::ReleaseMemory()
1.937 + {
1.938 + return iServer->ReleaseMemory();
1.939 + }
1.940 +
1.941 +TBool CWsTop::MultiFocusPolicy()
1.942 + {
1.943 + return iMultiFocusPolicy;
1.944 + }
1.945 +
1.946 +void CWsTop::ClearSurfaceMap(CWsClient *aClient)
1.947 + {
1.948 + TInt tempScreens = CWsTop::NumberOfScreens();
1.949 + for (TInt ii = 0; ii < tempScreens; ii++)
1.950 + {
1.951 + __DEBUG_ONLY(TInt err=)
1.952 + CWsTop::Screen(ii)->SurfaceMap()->RemoveAll(*aClient);
1.953 + WS_ASSERT_DEBUG((err==KErrNone||err==KErrNotFound||err==KErrInUse), EWsPanicSurfaceMapError);
1.954 + }
1.955 + }
1.956 +
1.957 +TBool CWsTop::SearchDuplicateSurfaceId(const TSurfaceId& aSurfaceId)
1.958 + {
1.959 + TInt tempScreens = CWsTop::NumberOfScreens();
1.960 + for (TInt ii = 0; ii < tempScreens; ii++)
1.961 + {
1.962 + if (CWsTop::Screen(ii)->WindowElements().SearchDuplicateSurfaceId(aSurfaceId))
1.963 + {
1.964 + return ETrue;
1.965 + }
1.966 + }
1.967 + return EFalse;
1.968 + }
1.969 +
1.970 +/**
1.971 +Checks to see if the render orientation has changed, and publishes any new orientaion
1.972 +via publish and subscribe
1.973 +
1.974 +@see KRenderOrientationCategory
1.975 +@see KRenderOrientationKey
1.976 +*/
1.977 +void CWsTop::CheckRenderOrientation()
1.978 + {
1.979 + iRenderOrientationTracker->CheckRenderOrientation();
1.980 + }
1.981 +
1.982 +typedef TInt (*ShellEntryPoint)(TAny *);
1.983 +
1.984 +#if defined(__WINS__)
1.985 +LOCAL_D const TUint KHeapSize=0x10000;
1.986 +LOCAL_D const TUint KMaxHeapSize=0x400000;
1.987 +#endif
1.988 +
1.989 +CWsShellLogon::CWsShellLogon() : CActive(EWsShellLogonPriority)
1.990 + {
1.991 +#if defined (__WINS__)
1.992 + // Clear handles to NULL so we can later detect which one gets used
1.993 + iShellThread.SetHandle(NULL);
1.994 + iShellProcess.SetHandle(NULL);
1.995 +#endif
1.996 + }
1.997 +
1.998 +CWsShellLogon::~CWsShellLogon()
1.999 + {
1.1000 + Cancel();
1.1001 +#if defined (__WINS__)
1.1002 + iShellThread.Close();
1.1003 + iShellProcess.Close();
1.1004 +#else
1.1005 + iShell.Close();
1.1006 +#endif
1.1007 +#if defined(__WINS__)
1.1008 + iLib.Close();
1.1009 +#endif
1.1010 + }
1.1011 +
1.1012 +void CWsShellLogon::ConstructL(RFs &)
1.1013 + {
1.1014 + CActiveScheduler::Add(this);
1.1015 + TPtrC shellCmd;
1.1016 +
1.1017 + _LIT(KWSERVIniFileVarShellCmd,"SHELLCMD");
1.1018 + WsIniFile->FindVar(KWSERVIniFileVarShellCmd,shellCmd);
1.1019 + _LIT(KWSERVShellName,"SHELL");
1.1020 + TPtrC startUp(KWSERVShellName);
1.1021 + _LIT(KWSERVIniFileVarStartUp,"STARTUP");
1.1022 + WsIniFile->FindVar(KWSERVIniFileVarStartUp,startUp);
1.1023 +
1.1024 +
1.1025 + TParse fileName;
1.1026 + _LIT(KWSERVArmShellLocationPattern,"Z:\\sys\\bin\\.EXE");
1.1027 + User::LeaveIfError(fileName.SetNoWild(startUp,&KWSERVArmShellLocationPattern,NULL));
1.1028 +#if defined(__WINS__)
1.1029 + TInt err=iShellProcess.Create(fileName.FullName(),shellCmd);
1.1030 + if (err == KErrNone)
1.1031 + {
1.1032 + Request();
1.1033 + iShellProcess.Resume();
1.1034 + }
1.1035 + else
1.1036 + {
1.1037 + // Try loading the matching DLL name instead?
1.1038 + _LIT(KWSERVShellExtension,"Z:.DLL");
1.1039 + User::LeaveIfError(fileName.Set(KWSERVShellExtension,&startUp,NULL));
1.1040 + User::LeaveIfError(iLib.Load(fileName.FullName()));
1.1041 + ShellEntryPoint libFunc=(ShellEntryPoint)iLib.Lookup(1);
1.1042 + if (!libFunc)
1.1043 + User::Leave(KErrGeneral);
1.1044 + TBuf<256> name;
1.1045 + TInt num=0;
1.1046 + TInt ret=KErrNone;
1.1047 + do
1.1048 + {
1.1049 + _LIT(KWSERVWinsShellInstanceName,"Shell%d");
1.1050 + name.Format(KWSERVWinsShellInstanceName,num++);
1.1051 + ret=iShellThread.Create(name,libFunc,KDefaultStackSize,&shellCmd,&iLib,NULL,KHeapSize,KMaxHeapSize,EOwnerProcess);
1.1052 + } while(ret==KErrAlreadyExists);
1.1053 + User::LeaveIfError(ret);
1.1054 + Request();
1.1055 + iShellThread.Resume();
1.1056 + }
1.1057 +#else // not __WINS__
1.1058 + User::LeaveIfError(iShell.Create(fileName.FullName(),shellCmd));
1.1059 + Request();
1.1060 + iShell.Resume();
1.1061 +#endif
1.1062 + return;
1.1063 +
1.1064 + }
1.1065 +
1.1066 +void CWsShellLogon::DoCancel()
1.1067 + {
1.1068 +#if defined (__WINS__)
1.1069 + if(iShellThread.Handle())
1.1070 + iShellThread.LogonCancel(iStatus);
1.1071 + else
1.1072 + iShellProcess.LogonCancel(iStatus);
1.1073 +#else
1.1074 + iShell.LogonCancel(iStatus);
1.1075 +#endif
1.1076 + }
1.1077 +
1.1078 +void CWsShellLogon::RunL()
1.1079 + {
1.1080 + if (iStatus.Int()!=KErrCancel)
1.1081 + CWsTop::ShellExited();
1.1082 + }
1.1083 +
1.1084 +void CWsShellLogon::Request()
1.1085 + {
1.1086 +#if defined (__WINS__)
1.1087 + if(iShellThread.Handle())
1.1088 + iShellThread.Logon(iStatus);
1.1089 + else
1.1090 + iShellProcess.Logon(iStatus);
1.1091 +#else
1.1092 + iShell.Logon(iStatus);
1.1093 +#endif
1.1094 + SetActive();
1.1095 + }
1.1096 +
1.1097 +#if defined(__WINS__)
1.1098 +TFullName CWsShellLogon::FullName()
1.1099 + {
1.1100 + if(iShellThread.Handle())
1.1101 + return(iShellThread.FullName());
1.1102 + else
1.1103 + return(iShellProcess.FullName());
1.1104 + }
1.1105 +#else
1.1106 +TFullName CWsShellLogon::FullName()
1.1107 + {return(iShell.FullName());}
1.1108 +#endif
1.1109 +
1.1110 +TInt E32Main()
1.1111 + {
1.1112 + __UHEAP_MARK;
1.1113 +
1.1114 + UserSvr::WsRegisterThread();
1.1115 +
1.1116 + RThread thread;
1.1117 + // Set wserv's main thread to system permanent
1.1118 + TInt err;
1.1119 + err = User::SetCritical(User::ESystemPermanent);
1.1120 + if (err!=KErrNone)
1.1121 + {
1.1122 + WS_PANIC_ALWAYS(EWsPanicFailedToSetThread);
1.1123 + }
1.1124 +// If in the future wserv becomes multi-threaded,
1.1125 +// we can uncomment the following lines to set any new threads to be system permanent as well.
1.1126 +// err = User::SetProcessCritical(User::ESystemPermanent);
1.1127 +// if (err!=KErrNone)
1.1128 +// {
1.1129 +// WS_PANIC_ALWAYS(EWsPanicFailedToSetProcess);
1.1130 +// }
1.1131 +
1.1132 + thread.SetPriority(EPriorityMore);
1.1133 + err = User::RenameThread(KWSERVThreadName);
1.1134 + if (err==KErrNone)
1.1135 + {
1.1136 + thread.Close();
1.1137 + }
1.1138 + else
1.1139 + {
1.1140 + return err;
1.1141 + }
1.1142 +
1.1143 + CTrapCleanup* CleanUpStack=CTrapCleanup::New();
1.1144 + TRAP(err, WsIniFile = CIniFile::NewL());
1.1145 + if (err!=KErrNone)
1.1146 + {
1.1147 + WS_PANIC_ALWAYS(EWsPanicFailedToInitialise);
1.1148 + }
1.1149 +
1.1150 + _LIT(KMemLeakCheck, "MEMLEAKCHECK");
1.1151 + if (WsIniFile->FindVar(KMemLeakCheck))
1.1152 + {
1.1153 + RDebug::Printf("The Memory Leak Check is Enabled => ECOM plugins are preload");
1.1154 + CWsPluginManager* pm = NULL;
1.1155 + TRAP(err,pm = CWsPluginManager::NewL());
1.1156 + delete pm;
1.1157 + if (err!=KErrNone)
1.1158 + {
1.1159 + WS_PANIC_ALWAYS(EWsPanicFailedToInitialise);
1.1160 + }
1.1161 + }
1.1162 +
1.1163 + // Define properties for singleton callbacks. This must only be done ONCE
1.1164 + // to ensure the properties can't be hijacked.
1.1165 + gReleaseSingletonsOnExit = ETrue;
1.1166 + DefineSingletonKey(KOpenWfcInteropCleanupKey);
1.1167 + DefineSingletonKey(KOpenWfcImplCleanupKey);
1.1168 +
1.1169 + TInt startCount;
1.1170 + do
1.1171 + {
1.1172 + User::Heap().__DbgMarkStart();
1.1173 + startCount=User::Heap().Count();
1.1174 + TRAP(err,CWsTop::RunServerL());
1.1175 + if (err!=KErrNone)
1.1176 + {
1.1177 + WS_PANIC_ALWAYS(EWsPanicFailedToInitialise);
1.1178 + }
1.1179 + UserSvr::ReleaseEventHook();
1.1180 + } while (CWsTop::NeedsHeapCheckAndRestart(startCount));
1.1181 +
1.1182 + REComSession::FinalClose(); // Now we can unload the plugins' dlls
1.1183 + delete WsIniFile;
1.1184 + delete CleanUpStack;
1.1185 +
1.1186 + __UHEAP_MARKEND;
1.1187 + return(err);
1.1188 + }
1.1189 +
1.1190 +