// 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 the License "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:

// e32\ewsrv\ws_main.cpp

// 

//

#include "ws_std.h"

#include <e32hal.h>

#include <hal.h>

#include <e32math.h>

#include <domainmanager.h>

#ifdef __WINS__

#include <e32wins.h>

#endif

GLREF_D CKeyTranslator *KeyTranslator;

GLREF_D CKeyRepeat* KeyRepeat;

// password notifier support functions

LOCAL_C void RenderPassword(RConsole *aCon, TInt aPWLeft, const TDesC& aPW);

_LIT(KShellProcessName, "ESHELL");

_LIT(KShellCommandLine, "/p");

//

// class CKeyRepeat

//

CKeyRepeat::CKeyRepeat(TInt aPriority) : CTimer(aPriority)

//

// Constructor. Set default repeat delay and rate

//

    {

    iDelay=EDefaultKeyRepeatDelay;

    iRate=EDefaultKeyRepeatRate;

    }

void CKeyRepeat::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add(this);

    }

void CKeyRepeat::RunL()

//

// Send a repeat keypress to the window

//

    {

    After(iRate);

	CWsWindow::KeyPress(iKeyData);

    }

void CKeyRepeat::Request(TKeyData& aKeyData)

//

// Request a repeat event

//

    {

    iKeyData=aKeyData;

	Cancel();

    After(iDelay);

    }

void CKeyRepeat::SetRepeatTime(TInt aDelay,TInt aRate)

    {

    iDelay=aDelay;

    iRate=aRate;

    }

void CKeyRepeat::RepeatTime(TInt& aDelay,TInt& aRate)

    {

    aDelay=iDelay;

    aRate=iRate;

    }

//

// class CWsSession

//

CWsSession::CWsSession()

	{

	iTestFast = (UserSvr::DebugMask(2)&0x00000002) ? 1 : 0;

	}

CWsSession::~CWsSession()

//

// Destructor

//

	{

	delete iWindow;

	}

//

// class CWsServer

//

void CWsServer::New()

//

// Create a new CWsServer.

//

	{

	CWsServer *pS=new CWsServer(EPriority);

	__ASSERT_ALWAYS(pS!=NULL,Fault(ECreateServer));

	pS->SetPinClientDescriptors(EFalse); // don't pin because client interface can't cope with errors if pin fails under real or simulated OOM

	TInt r=pS->Start(KE32WindowServer);

	__ASSERT_ALWAYS(r==KErrNone,Fault(EStartServer));

	RProcess::Rendezvous(KErrNone);

	}

CWsServer::CWsServer(TInt aPriority)

//

// Constructor.

//

	: CServer2(aPriority)

	{

	}

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

//

// Create a new client for this server.

//

	{

	TVersion v(KW32MajorVersionNumber,KW32MinorVersionNumber,KE32BuildVersionNumber);

	TBool r=User::QueryVersionSupported(v,aVersion);

	if (!r)

		User::Leave(KErrNotSupported);

	return new(ELeave) CWsSession;

	}

void CWsSession::ServiceL(const RMessage2& aMessage)

//									    

// Handle messages for this session.

//

	{

	iCurMsg = aMessage;

	CWsWindow::WaitOnService();

	CWsWindow* pW=iWindow;

	TInt r=EPrematureOperation;

	TBool delayCompletion=EFalse;

	switch (aMessage.Function())

		{

	case EConsoleCreate:

		{

		if (pW)

			{

			delete pW;

			iWindow=NULL;

			}

		pW=new CWsWindow;

		if (!pW)

			{ 

			r=EWindowOutOfMemory;

			break;

			}

		iWindow=pW;

		pW->iAllowResize=ETrue;

		pW->iIsVisible=ETrue;

		pW->iOnTop=EFalse;

		pW->SetCursorHeight(50);

		pW->iKQueue.SetOffset(_FOFF(SWsKey,iLink));

		break;

		}

	case EConsoleSet:

		{

		if (!pW)

			{

			pW=new(ELeave) CWsWindow;

			iWindow=pW;

			pW->iAllowResize=ETrue;

			pW->iIsVisible=ETrue;

			pW->iOnTop=EFalse;

			pW->SetCursorHeight(50);

			pW->iKQueue.SetOffset(_FOFF(SWsKey,iLink));

			}

		pW->iAllowSlide=ETrue;

		TFileName name;

		iCurMsg.ReadL(0, name);

		pW->iTitle=name;

		TPckgBuf<TSize> size;

		iCurMsg.ReadL(1, size);

		TRAP(r,pW->CreateL(size()));

		if (r != KErrNone)

			{

			delete pW;

			iWindow=NULL;			

			}

		break;

		}

	case EConsoleClearScreen:

		{

		if (pW)

			{

			pW->Clear();

			r=KErrNone;

			}

		break;

		}

	case EConsoleClearToEndOfLine:

		{

		if (pW)

			{

			pW->ClearToEndOfLine();

			r=KErrNone;

			}

		break;

		}

	case EConsoleSetTitle:

		{

		if (pW)

			{

			TFileName name;

			iCurMsg.ReadL(0, name);

			pW->SetTitle(name);

			r=KErrNone;

			}

		break;

		}

	case EConsoleSetSize:

		{

		if (pW)

			{

			TPckgBuf<TSize> size;

			iCurMsg.ReadL(0, size);

//			pW->SetSize(size());

//			r=KErrNone;

			r=KErrNotSupported;

			}

		break;

		}

	case EConsoleSetWindowPosAbs:

		{

		if (pW)

			{

			TPckgBuf<TPoint> point;

			iCurMsg.ReadL(0, point);

			pW->SetWindowPosAbs(point());

			r=KErrNone;

			}

		break;

		}

	case EConsoleSetCursorHeight:

		{

		if (pW)

			{

			pW->SetCursorHeight(aMessage.Int0());

			r=KErrNone;

			}

		break;

		}

	case EConsoleSetCursorPosAbs:

		{

		if (pW)

			{

			TPckgBuf<TPoint> point;

			iCurMsg.ReadL(0, point);

			pW->SetCursorPosAbs(point());

			r=KErrNone;

			}

		break;

		}

	case EConsoleSetCursorPosRel:

		{

		if (pW)

			{

			TPckgBuf<TPoint> point;

			iCurMsg.ReadL(0, point);

			pW->SetCursorPosRel(point());

			r=KErrNone;

			}

		break;

		}

	case EConsoleCursorPos:

		{

		if (pW)

			{

			TPckgBuf<TPoint> point;

			point()=pW->CursorPosition();

			aMessage.WriteL(0,point);

			r=KErrNone;

			}

		break;

		}

	case EConsoleSize:

		{

		if (pW)

			{

			TPckgBuf<TSize> size;

			size()=pW->Size();

			aMessage.WriteL(0,size);

			r=KErrNone;

			}

		break;

		}

	case EConsoleScreenSize:

		{

		if (pW)

			{

			TPckgBuf<TSize> size;

			size()=CWsWindow::ScreenSize;

			aMessage.WriteL(0,size);

			r=KErrNone;

			}

		break;

		}

	case EConsoleControl:

		{

		if (pW)

			{

			TBool indicator=ETrue;

			TInt offset=0;

			TBuf<0x100> b;

			do

				{

				iCurMsg.ReadL(0,b,offset);

				for (const TText* pB=b.Ptr();pB<b.Ptr()+b.Length();pB++)

					{

					switch(*pB)

						{

					case '+':

						indicator=ETrue;

						break;

					case '-':

						indicator=EFalse;

						break;

					case 'S':

						pW->ControlScrollBars(indicator);

						break;

					case 'W':

						pW->ControlWrapLock(indicator);

						break;

                    case 'P':

                        pW->ControlPointerEvents(indicator);

                        break;

					case 'L':

						pW->ControlScrollLock(indicator);

						break;

					case 'V':

						pW->ControlVisibility(indicator);

						break;

					case 'C':

						pW->ControlCursorRequired(indicator);

						break;

					case 'M':

						pW->ControlMaximised(indicator);

						break;

					case 'N':

						pW->ControlNewLineMode(indicator);

						break;

                    case 'O':

						pW->ControlOnTop(indicator);

						break;

					case 'I':

                        pW->ControlInformAllMouse(indicator);

                        break;

                    case 'R':

                        pW->ControlRawEventMode(indicator);

                        break;

					case 'A':

						pW->ControlAllowResize(indicator);

						}

					}

				offset+=b.Length();

				}

			while (b.Length()==b.MaxLength());

			r=KErrNone;

			}

		break;

		}

	case EConsoleWrite:

		{

		if (pW)

			{

			switch(iTestFast)

				{

			case 0:

				{

				TInt offset=0;

				TBuf<0x100> b;

				do

					{

					iCurMsg.ReadL(0,b,offset);

					pW->Write(b);

					offset+=b.Length();

					}

				while (b.Length()==b.MaxLength());

				pW->WriteDone();

				}

				r=KErrNone;

				break;

			case 1:

				{

				pW->Write(_L("Output suppressed because TESTFAST mode is set..."));

				pW->WriteDone();

				++iTestFast;

				}

				r=KErrNone;

				break;

			default:

				r=KErrNone;

				break;

				}

			}

		break;

		}

	case EConsoleRead:

		{

		if (pW)

			{

			if (pW->EnqueReadRequest(aMessage))

				{

				delayCompletion=ETrue;

				r=KErrNone;

				}

			else

				r=EDoubleReadRequest;

			}

		break;

		}

	case EConsoleReadCancel:

		{

		if (pW)

			{

			pW->DequeReadRequest();

			r=KErrNone;

			}

		break;

		}

	case EConsoleDestroy:

		{

		if (pW)

			{

			delete pW;

			iWindow=NULL;

			r=KErrNone;

			}

		break;

		}

	case EConsoleSetMode:

		{

		r=CWsWindow::SetMode((TVideoMode)aMessage.Int0());		

		break;

		}

	case EConsoleSetPaletteEntry:

		{

		CWsWindow::ScreenDriver->SetPaletteEntry((TColorIndex)aMessage.Int0(),(TUint8)aMessage.Int1(),(TUint8)aMessage.Int2(),(TUint8)aMessage.Int3());

		pW->Redraw();

		r=KErrNone;

		break;

		}

	case EConsoleGetPaletteEntry:

		{

		TUint8 r,g,b;

		TPckgBuf<TUint8> red,green,blue;

		CWsWindow::ScreenDriver->GetPaletteEntry((TColorIndex)aMessage.Int0(),r,g,b);

		red()=r; green()=g; blue()=b;

		aMessage.WriteL(1,red);

		aMessage.WriteL(2,green);

		aMessage.WriteL(3,blue);

		}

		r=KErrNone;

		break;

	case EConsoleSetTextColors:

		{

		if(pW)

			{

			pW->iFgColor=(TColorIndex)aMessage.Int0();

			pW->iBgColor=(TColorIndex)aMessage.Int1();

			}		

		r=KErrNone;

		break;

		}

	case EConsoleSetUIColors:

		{

		CWsWindow::WindowBgColor=(TColorIndex)aMessage.Int0();

		CWsWindow::BorderColor=(TColorIndex)aMessage.Int1();

		CWsWindow::ScreenColor=(TColorIndex)aMessage.Int2();

		CWsWindow::ChangeUIColors();

		r=KErrNone;

		break;

		}

	case EConsoleSetTextAttribute:

		{

		if(pW)

			pW->SetTextAttribute((TTextAttribute)aMessage.Int0());		

		r=KErrNone;

		break;

		}

	default:

		r=KErrNotSupported;

		}

	if (!delayCompletion)

		aMessage.Complete(r);

	CWsWindow::SignalService();

	}

void CWsSession::ServiceError(const RMessage2& aMessage,TInt aError)

	{

	if (!aMessage.IsNull())

		{

		if (aError>0)

			{

			aMessage.Panic(_L("WServ panic"),aError);

			}

		else

			{

			aMessage.Complete(aError);

			}

		}

	}

CWsServer::~CWsServer()

//

// Destructor

//

	{

	}

//

// class CEvent

//

void CEvent::New()

//

// Create the CEvent active object.

//

	{

	CEvent *pE=new CEvent(EPriority);

	__ASSERT_ALWAYS(pE!=NULL,Fault(ECreateEvent));

	pE->CaptureKeys=new CCaptureKeys();

	__ASSERT_ALWAYS(pE->CaptureKeys!=NULL,Fault(ECreateEvent));

	pE->CaptureKeys->Construct();

	CActiveScheduler::Add(pE);

	UserSvr::CaptureEventHook();

	pE->Request();

	}

CEvent::~CEvent()

//

// Destroy the CEvent active object

//

	{

	Cancel();

	}

#pragma warning( disable : 4705 )	// statement has no effect

CEvent::CEvent(TInt aPriority)

//

// Constructor

//

	: CActive(aPriority)

	{

	}

#pragma warning( default : 4705 )

void CEvent::Request()

//

// Issue a request for the next event.

//

	{

	UserSvr::RequestEvent(iEvent,iStatus);

	SetActive();

	}

void CEvent::DoCancel()

//

// Cancel a pending event.

//

	{

	UserSvr::RequestEventCancel();

	}

void CEvent::RunL()

//

// Event has completed.

//

	{

    if (CWsWindow::RawEventMode())

        {

        KeyRepeat->Cancel();

        CWsWindow::QueueRawEvent(iEvent.Event());

        Request();

        return;

        }

	switch(iEvent.Event().Type())

		{

	case TRawEvent::ERedraw:

		CWsWindow::Redraw();

		break;

	case TRawEvent::EButton1Down:

        if(!CWsWindow::MouseIsCaptured)

            {

      		CWsWindow::MouseMove(iEvent.Event().Pos());

  	    	CWsWindow::MouseLeftButton();

            }

        else

            CWsWindow::InformTopMouse(iEvent.Event().Pos());

		break;

	case TRawEvent::EButton1Up:

		if(!CWsWindow::MouseIsCaptured)

			{

			CWsWindow::MouseMove(iEvent.Event().Pos());

			CWsWindow::MouseLeftButtonUp();

			}

		break;

	case TRawEvent::EButton2Down:

		break;

	case TRawEvent::EButton2Up:

		break;

	case TRawEvent::EButton3Down:

		break;

	case TRawEvent::EButton3Up:

		break;

	case TRawEvent::EPointerMove:

		CWsWindow::MouseMove(iEvent.Event().Pos());

		break;

	case TRawEvent::EInactive:

        KeyRepeat->Cancel();

        break;

    case TRawEvent::EActive:

        break;

    case TRawEvent::EUpdateModifiers:

        KeyTranslator->UpdateModifiers(iEvent.Event().Modifiers());

        break;

	case TRawEvent::EKeyDown:

		{

		TKeyData keyData;

		if (KeyTranslator->TranslateKey(iEvent.Event().ScanCode(), EFalse,*CaptureKeys,keyData))

			CWsWindow::KeyPress(keyData);

		if (keyData.iModifiers&EModifierAutorepeatable)

			KeyRepeat->Request(keyData);

		break;

		}

	case TRawEvent::EKeyUp:

		{

		TKeyData keyData;

		KeyRepeat->Cancel();

		if (KeyTranslator->TranslateKey(iEvent.Event().ScanCode(), ETrue,*CaptureKeys,keyData))

			CWsWindow::KeyPress(keyData);

		break;

		}

	case TRawEvent::ESwitchOn:

	case TRawEvent::ECaseOpen:

		HAL::Set(HAL::EDisplayState, 1);

			{

			RDmDomainManager mgr; 

			TInt r = mgr.Connect();

			if (r != KErrNone)

				User::Panic(_L("EWSRV SwitchOn0"), r);

			TRequestStatus status;

			mgr.RequestDomainTransition(KDmIdUiApps, EPwActive, status);

			User::WaitForRequest(status);

			if (status.Int() != KErrNone)

				User::Panic(_L("EWSRV SwitchOn1"), status.Int());

			mgr.Close();

			}

		break;

	case TRawEvent::EPointerSwitchOn:

#if defined(_DEBUG)

    	User::Beep(440,250000);

#endif

		break;

	case TRawEvent::ESwitchOff:

			{

			RDmDomainManager mgr; 

			TInt r = mgr.Connect();

			if (r != KErrNone)

				User::Panic(_L("EWSRV SwitchOff0"), r);

			TRequestStatus status;

			mgr.RequestSystemTransition(EPwStandby, status);

			User::WaitForRequest(status);

			if (status.Int() != KErrNone)

				User::Panic(_L("EWSRV SwitchOff1"), status.Int());

			mgr.Close();

			}

		break;

	case TRawEvent::ECaseClose:

			{

			RDmDomainManager mgr; 

			TInt r = mgr.Connect();

			if (r != KErrNone)

				User::Panic(_L("EWSRV CaseClosed"), r);

			TRequestStatus status;

			mgr.RequestDomainTransition(KDmIdUiApps, EPwStandby, status);

			User::WaitForRequest(status);

			if (status.Int() != KErrNone)

				User::Panic(_L("EWSRV CaseClosed1"), status.Int());

			mgr.Close();

			}

		HAL::Set(HAL::EDisplayState, 0);

		break;

	case TRawEvent::ENone:

		break;

	default:

		break;

		}                                       

	Request();

	}

LOCAL_C void RenderPassword(RConsole *aCon, TInt aPWLeft, const TDesC& aPW)

// pre:		aCon points to a console being used to read a password.

//			aPWLeft is the column number from which the left brace should be drawn.

//			aPasswd is a valid password.

// post:	the password is rendered onto the console and followed by a '#' and

//			padding spaces.  Everything is enclosed in a pair of square brackets.

	{

	aCon->SetCursorPosAbs(TPoint(aPWLeft, 3));

	aCon->Write(_L("["));

	aCon->Write(aPW);

	aCon->Write(_L("#"));

	TInt i;

	for (i = 0; i < KMaxMediaPassword - aPW.Length(); i++)

		{

		aCon->Write(_L(" "));

		}

	aCon->Write(_L("]"));

	}

void CNotifierSession::RunPasswordWindowL(const RMessage2 &aMsg)

//

// Eight unicode chars are mapped to (up to) sixteen bytes.  Remainder of array is

// zeroed.  Message is completed in CNotifierSession::ServiceL().

// 

	{

	// local copies of dialog data, 5 * (8 + 32 * 2) bytes

	TBuf<0x20> line1, line2, unlockBtn, storeBtn, cancelBtn;

	line1.Copy(_L("Password notifier"));

	line2.Copy(_L("Enter password"));

	unlockBtn.Copy(_L("Unlock"));

	storeBtn.Copy(_L("Store"));

	cancelBtn.Copy(_L("Cancel"));

	TPckgBuf<TMediaPswdReplyNotifyInfoV1> reply;

	// Format the console window.

	const TInt KPasswordBarLen(1 + KMaxMediaPassword + 1 + 1);

	const TInt KButtonBarLen(

				1 + unlockBtn.Length() + 1

		+ 1 +	1 + cancelBtn.Length() + 1

		+ 1 +	1 + storeBtn.Length() + 1);

	// Work out width of window.

	// (Buttons are enclosed by angle brackets and separted by a space.)

	// (Password is followed by '#' and delimited by square brackets.)

	// If KButtonBarLen is at least as long as any other line then it will write

	// to the bottom right corner and cause the console to scroll.  To counter

	// this, an extra padding character is added if necessary.

	TInt width;

	width = Max(line1.Length(), line2.Length());

	width = Max(width, KPasswordBarLen);

	width = KButtonBarLen >= width ? KButtonBarLen + 1: width;

	// Create the window and render its contents.

	RConsole con;

	con.Create();

	con.Control(_L("-Visible"));

	TInt r = con.Init(_L(""), TSize(width, 2 + 1 + 1 + 1 + 1));

	if (KErrNone != r)

		{

		PanicClient(aMsg, ENotifierPanicPasswordWindow);

		User::Leave(KErrGeneral);

		}

	con.Control(_L("+Max -Cursor -AllowResize +OnTop"));

	con.SetCursorPosAbs(TPoint(0, 0));

	con.Write(line1);

	con.SetCursorPosAbs(TPoint(0, 1));

	con.Write(line2);

	const TInt KPasswordLeft((width - KPasswordBarLen) / 2);

	con.SetCursorPosAbs(TPoint(KPasswordLeft, 3));

	con.Write(_L("[#                ]"));

	con.SetCursorPosAbs(TPoint((width - KButtonBarLen) / 2, 5));

	con.Write(_L("<"));

	con.Write(unlockBtn);

	con.Write(_L("> <"));

	con.Write(storeBtn);

	con.Write(_L("> <"));

	con.Write(cancelBtn);

	con.Write(_L(">"));

	// Allow the user to edit the password until they either press enter or escape.

	TBool done(EFalse);

	TBuf<KMaxMediaPassword> pw;

	pw.Zero();

	TMediaPswdNotifyExitMode em(EMPEMUnlock);	// avoid VC warning C4701 (used w/o init).

	const TInt sendInfoLen = User::LeaveIfError(aMsg.GetDesLength(1));

	if (sendInfoLen == sizeof(TMediaPswdSendNotifyInfoV1Debug))

		{

		// debug mode - wait for specified period and close notifier

		TPckgBuf<TMediaPswdSendNotifyInfoV1Debug> sendDbg;

		aMsg.ReadL(1, sendDbg);

		if (sendDbg().iSleepPeriod >= 0)

			User::After(sendDbg().iSleepPeriod);

		else

			{

			TTime now;

			now.HomeTime();

			TInt64 seed = now.Int64();

			User::After(Math::Rand(seed) % -(sendDbg().iSleepPeriod));

			}

		reply().iEM = sendDbg().iEM;

		Mem::Copy(reply().iPW, sendDbg().iPW, KMaxMediaPassword);

		}

	else

		{

		RenderPassword(&con, KPasswordLeft, pw);

		do

			{

			TConsoleKey key;

			con.Read(key);

			TInt keyCode = key.Code();

			switch (keyCode)

				{

				case EKeyEscape:

					em = EMPEMCancel;

					done = ETrue;

					break;

				case EKeyEnter:

					em = EMPEMUnlock;

					done = ETrue;

					break;

				case EKeySpace:

					em = EMPEMUnlockAndStore;

					done = ETrue;

					break;

				case EKeyBackspace:

					if (pw.Length() > 0)

						{

						pw.SetLength(pw.Length() - 1);

						RenderPassword(&con, KPasswordLeft, pw);

						}

					break;

				default:							// interpret other keys as pw contents

					TChar ch(keyCode);

					// unicode encoding, so number of password characters is half byte length

					if (ch.IsPrint() && pw.Length() < KMaxMediaPassword / 2)

						{

						pw.Append(ch);

						RenderPassword(&con, KPasswordLeft, pw);

						}

					break;

				}

			} while (! done);

		// Fill the TMediaPswdReplyNotifyInfoV1 structure.

		if (em == EMPEMUnlock || em == EMPEMUnlockAndStore)

			{

			const TInt byteLen = pw.Length() * 2;

			// zero entire array; and then copy in valid section of TMediaPassword,

			// not converting Unicode to ASCII.

			TPtr8 pt8(reply().iPW, KMaxMediaPassword);	// length = 0

			pt8.FillZ(KMaxMediaPassword);				// length = KMaxMediaPassword

			pt8.Zero();									// length = 0

														// length = byteLen

			pt8.Copy(reinterpret_cast<const TUint8 *>(pw.Ptr()), byteLen);

			}

		// Set exit mode to tell user how dialog handled.

		reply().iEM = em;

		}	// else (sendInfoLen == sizeof(TMediaPswdSendNotifyInfoV1Debug))

	con.Destroy();

	aMsg.WriteL(2, reply);

	}

//

// class MNotifierBase2

//

void MNotifierBase2::SetManager(MNotifierManager* aManager)

	{

	iManager=aManager;

	}

//

// class CNotifierServer

//

_LIT(__NOTIFIER_SERVER,"TextNotifierSrvr");

CNotifierServer* CNotifierServer::NewL()

	{

	CNotifierServer* server=new(ELeave) CNotifierServer(200);

	CleanupStack::PushL(server);

	server->ConstructL();

	server->StartL(__NOTIFIER_NAME);

	CleanupStack::Pop(); // server

	return server;

	}

CNotifierServer::~CNotifierServer()

	{

	SetIsExiting();

	delete iManager;

	}

void CNotifierServer::SetIsExiting()

	{

	iExiting=ETrue;

	}

TBool CNotifierServer::IsExiting() const

	{

	return iExiting;

	}

CNotifierServer::CNotifierServer(TInt aPriority)

	: CServer2(aPriority)

	{}

void CNotifierServer::ConstructL()

	{

	iManager=CNotifierManager::NewL();

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	iManager->RegisterL(fs);

	CleanupStack::PopAndDestroy(); // fs.Close()

	}

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

	{

	TVersion v(1,0,0); // !! liaise with E32

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

		User::Leave(KErrNotSupported);

	return new(ELeave) CNotifierSession(*this);

	}

//

// class CNotifierSession

//

CNotifierSession::CNotifierSession(const CNotifierServer& aServer)

	{

	iServer=&aServer;

	iClientId=(TInt)this;

	}

CNotifierSession::~CNotifierSession()

	{

	const CNotifierServer* server=static_cast<const CNotifierServer*>(Server());

	if (!server->IsExiting())

		{

		server->Manager()->HandleClientExit(iClientId);