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

 		}

 	}

 void CNotifierSession::ServiceL(const RMessage2 &aMessage)

 	{

 	TBool completeMessage=ETrue;

 	switch (aMessage.Function())

 		{

 	case ENotifierNotify:

 		DisplayAlertL(aMessage);

 		break;

 	case ENotifierNotifyCancel:

 		// do nothing - this server doesn't support cancelling RNotifier::Notify - the client will just have to wait

 		break;

 	case ENotifierInfoPrint:

 		DisplayInfoMsgL(aMessage);

 		break;

 	case EStartNotifier:

 		DoStartNotifierL(aMessage);

 		break;

 	case ECancelNotifier:

 		iServer->Manager()->NotifierCancel(TUid::Uid(aMessage.Int0()));

 		break;

 	case EUpdateNotifierAndGetResponse:

 	case EUpdateNotifier:

 		DoUpdateNotifierL(aMessage);

 		break;

 	case EStartNotifierAndGetResponse:

 		{

 		if (aMessage.Int0()==KMediaPasswordNotifyUid)

 			{

 			RunPasswordWindowL(aMessage);

 			}

 		else

 			{

 			TBool cleanupComplete=ETrue;

 			StartNotifierAndGetResponseL(aMessage,cleanupComplete);

 			 // if the plug-in starts successfully, it has

 			 // responsibility for completing the message (either

 			 // synchronously or asynchronously)

 			completeMessage=EFalse;

 			}

 		}

 		break;

 	default:

 		aMessage.Complete(KErrNotSupported);

 		break;

 		}

 	if (completeMessage && !aMessage.IsNull())

 		{

 		aMessage.Complete(KErrNone);

 		}

 	}

 void CNotifierSession::DisplayAlertL(const RMessage2& aMessage)

 	{

 	const TInt lengthOfCombinedBuffer=User::LeaveIfError(aMessage.GetDesLength(1));

 	const TInt lengthOfLine1=(STATIC_CAST(TUint,aMessage.Int2())>>16);

 	const TInt lengthOfLine2=(aMessage.Int2()&KMaxTUint16);

 	const TInt lengthOfBut1=(STATIC_CAST(TUint,aMessage.Int3())>>16);

 	const TInt lengthOfBut2=(aMessage.Int3()&KMaxTUint16);

 	if (lengthOfCombinedBuffer!=lengthOfLine1+lengthOfLine2+lengthOfBut1+lengthOfBut2)

 		{

 		PanicClient(aMessage,ENotifierPanicInconsistentDescriptorLengths);

 		return;

 		}

 	HBufC* const combinedBuffer=HBufC::NewLC(lengthOfCombinedBuffer);

 	{TPtr combinedBuffer_asWritable(combinedBuffer->Des());

 	aMessage.ReadL(1,combinedBuffer_asWritable);}

 	const TPtrC line1(combinedBuffer->Left(lengthOfLine1));

 	const TPtrC line2(combinedBuffer->Mid(lengthOfLine1,lengthOfLine2));

 	const TPtrC but1(combinedBuffer->Mid(lengthOfLine1+lengthOfLine2,lengthOfBut1));

 	const TPtrC but2(combinedBuffer->Mid(lengthOfLine1+lengthOfLine2+lengthOfBut1,lengthOfBut2));

 	TInt buttons, len, offset;

 	if (lengthOfBut2==0)

 		{

 		buttons=1;

 		len=lengthOfBut1+2;

 		}

 	else

 		{

 		buttons=2;

 		len=lengthOfBut1+lengthOfBut2+5;

 		}

 	if (lengthOfLine1>len)

 		len=lengthOfLine1;

 	if (lengthOfLine2>len)

 		len=lengthOfLine2;

 	RConsole con;

 	con.Create();

 	TSize scsz;

 	con.ScreenSize(scsz);

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

 	TInt ww=Min(len,scsz.iWidth-4);

 	TInt wh=3;

 	if ((lengthOfBut1+lengthOfBut2+5)>ww)

 		wh++;

 	if (lengthOfLine1>ww)

 		wh++;

 	if (lengthOfLine2>ww)

 		wh++;

 	con.Init(_L(""),TSize(ww,wh));

 	con.Control(_L("+Max -Cursor -Allowresize +Ontop +Wrap"));

 	con.Write(line1);

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

 	con.Write(line2);

 	if (buttons==2)

 		offset=(len-lengthOfBut1-lengthOfBut2-5)/2;

 	else

 		offset=(len-lengthOfBut1-2)/2;

 	con.SetCursorPosAbs(TPoint(offset,2));

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

 	con.Write(but1);

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

 	if(buttons==2)

 		{

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

 		con.Write(but2);

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

 		}

 	TConsoleKey key;

 	TInt keycode;

 	do

 		{

 		con.Read(key);

 		keycode=key.Code();

 		}

 	while((keycode!=EKeyEscape&&keycode!=EKeyEnter&&buttons==2)||(keycode!=EKeyEnter&&buttons==1));

 	if(keycode==EKeyEscape)

 		keycode=0;

 	else

 		keycode=1;

 	con.Destroy();

 	aMessage.WriteL(0,TPckgC<TInt>(keycode));

 	CleanupStack::PopAndDestroy(combinedBuffer);

 	}

 TInt CNotifierSession::InfoPrintThread(TAny* aMessage)

 	{

 	TBuf<0x50> des; // 0x50 max size of message

 	RConsole con;

 	des=*(TBuf<0x50> *)aMessage;

 	TInt l=des.Length();

 	NotifierSemaphore.Signal();

 	con.Create();

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

 	TSize size;

 	con.ScreenSize(size);

 	TInt ww=Min(size.iWidth-6,l);

 	TInt wh=(l+ww-1)/ww;

 	if (wh==0)

 		wh=1;

 	con.Init(_L(""),TSize(ww,wh));

 	con.Control(_L("+Maximise"));

 	con.SetWindowPosAbs(TPoint(size.iWidth-ww-4,1));

 	con.Control(_L("+Wrap +Ontop"));

 	con.Write(des);

 	User::After(1300000);

 	con.Destroy();

 	return KErrNone;

 	}

 void CNotifierSession::DisplayInfoMsgL(const RMessage2& aMessage)

 	{

 	TInt r;

 	TBuf<0x50> des; // 0x50 max size of message lines

 	aMessage.ReadL(0,des);

 	RThread thread;

 	do

 		{

 		r=thread.Create(_L("Info Window"),InfoPrintThread,KDefaultStackSize,&User::Allocator(),(TAny*)&des);

 		if(r==KErrAlreadyExists)

 			User::After(200000);

 		} while(r==KErrAlreadyExists);

 		User::LeaveIfError(r);

 	thread.Resume();

 	NotifierSemaphore.Wait();

 	thread.Close();

 	}

 void CNotifierSession::DoStartNotifierL(const RMessage2& aMessage)

 	{

 	const TUid targetUid={aMessage.Int0()};

 	HBufC8* const inputBuffer=HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(1)));

 	{TPtr8 input(inputBuffer->Des());

 	aMessage.ReadL(1,input);}

 	TPtrC8 output(0,0);

 	iServer->Manager()->NotifierStartL(targetUid,*inputBuffer,&output,iClientId);

 	if(aMessage.Int2())

 		aMessage.WriteL(2,output);

 	CleanupStack::PopAndDestroy(inputBuffer);

 	}

 void CNotifierSession::DoUpdateNotifierL(const RMessage2& aMessage)

 	{

 	const TUid targetUid={aMessage.Int0()};

 	HBufC8* const inputBuffer=HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(1)));

 	{TPtr8 input(inputBuffer->Des());

 	aMessage.ReadL(1, input);}

 	HBufC8* const outputBuffer=HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesMaxLength(2)));

 	{TPtr8 output(outputBuffer->Des());

 	iServer->Manager()->NotifierUpdateL(targetUid,*inputBuffer,&output,iClientId);}

 	aMessage.WriteL(2,*outputBuffer);

 	CleanupStack::PopAndDestroy(2,inputBuffer);

 	}

 void CNotifierSession::StartNotifierAndGetResponseL(const RMessage2& aMessage,TBool& aCleanupComplete)

 	{

 	const TUid targetUid={aMessage.Int0()};

 	HBufC8* const inputBuffer=HBufC8::NewLC(User::LeaveIfError(aMessage.GetDesLength(1)));

 	{TPtr8 input(inputBuffer->Des());

 	aMessage.ReadL(1,input);}

 	iServer->Manager()->NotifierStartAndGetResponseL(targetUid,*inputBuffer,2,aMessage,iClientId,aCleanupComplete);

 	CleanupStack::PopAndDestroy(inputBuffer);

 	}

 void CNotifierSession::PanicClient(const RMessage2& aMessage,TNotifierPanic aCode)

 	{

 	aMessage.Panic(__NOTIFIER_SERVER,aCode);

 	}

 //

 // class CNotifierManager

 //

 const TInt KNullClientId=0;

 CNotifierManager* CNotifierManager::NewL()

 	{

 	CNotifierManager* self=new(ELeave) CNotifierManager;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CNotifierManager::~CNotifierManager()

 	{

 	if (iObservedList)

 		{

 		const TInt count=iObservedList->Count();

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

 			{

 			(*iObservedList)[ii]->Release();

 			}

 		delete iObservedList;

 		}

 	if (iLibraries)

 		{

 		const TInt count=iLibraries->Count();

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

 			{

 			(*iLibraries)[ii].Close();

 			}

 		delete iLibraries;

 		}

 	delete iChannelMonitor;

 	delete iActivityMonitor;

 	delete iQueue;

 	}

 void CNotifierManager::RegisterL(RFs& aFs)

 	{

 #ifdef SUPPORT_OLD_PLUGIN_PATH

 	TBool old;

 	for(old=0; old<2; old++)

 	{

 #endif

 	TFindFile* findFile=new(ELeave) TFindFile(aFs);

 	CleanupStack::PushL(findFile);

 	TParse* fileNameParser=new(ELeave) TParse;

 	CleanupStack::PushL(fileNameParser);

 	CDir* directory=NULL;

 	TInt error;

 #ifdef SUPPORT_OLD_PLUGIN_PATH

 	_LIT(KNotifierPlugInOldSearchPath,"\\system\\tnotifiers\\");

 	if(old)

 		error=findFile->FindWildByDir(KNotifierPlugInExt, KNotifierPlugInOldSearchPath, directory);

 	else

 #endif

 	error=findFile->FindWildByDir(KNotifierPlugInExt, KNotifierPlugInSearchPath, directory);

 	for (; error!=KErrNotFound; error=findFile->FindWild(directory))

 		{

 		CleanupStack::PushL(directory);

 		User::LeaveIfError(error);

 		const TInt numberOfEntries=directory->Count();

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

 			{

 			const TEntry& entry=(*directory)[i];

 			fileNameParser->SetNoWild(entry.iName, &findFile->File(), NULL); // findFile->File() returns a reference rather than an object, therefore taking the address of it is fine

 			if (entry.iType[0].iUid==0x10000079)

 				{

 				 // It's a DLL

 				if( (entry.iType[1]==KUidTextNotifierPlugInV2))

 					{

 					// Its a notifier...

 					TPtrC path(fileNameParser->DriveAndPath());

 					TPtrC name(fileNameParser->NameAndExt());

 					DoAddPlugInL(path,name,entry.iType);

 					}

 				}

 			}

 		CleanupStack::PopAndDestroy(); // directory

 		directory=NULL;

 		}

 	delete directory;

 	CleanupStack::PopAndDestroy(2); // fileNameParser and findFile

 #ifdef SUPPORT_OLD_PLUGIN_PATH

 	}

 #endif

 	}

 LOCAL_C void DeleteTemp(TAny* aPtr)

 	{

 	CArrayPtr<MNotifierBase2>* array=REINTERPRET_CAST(CArrayPtr<MNotifierBase2>*,aPtr);

 	const TInt count=array->Count();

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

 		{

 		(*array)[ii]->Release();

 		}

 	delete array;

 	}

 void CNotifierManager::DoAddPlugInL(const TDesC& aPath,const TDesC& aFileName,const TUidType& aUidType)

 	{

 	RLibrary lib;

 	User::LeaveIfError(lib.Load(aFileName,aPath,aUidType));

 	CleanupClosePushL(lib);

 	iLibraries->AppendL(lib);

 	CleanupStack::Pop(); // lib

 	TLibraryFunction libEntry=lib.Lookup(1);

 	CArrayPtr<MNotifierBase2>* array=REINTERPRET_CAST(CArrayPtr<MNotifierBase2>*,(libEntry)());

 	User::LeaveIfNull(array);

 	CleanupStack::PushL(TCleanupItem(DeleteTemp,array));

 	while (array->Count()>0)

 		{

 		MNotifierBase2* notif=(*array)[0];

 			{

 			iObservedList->AppendL(notif);

 			array->Delete(0);

 			notif->SetManager(this);

 			}

 		MNotifierBase2::TNotifierInfo info=notif->RegisterL();

 		if (!iChannelMonitor->AlreadyHasChannel(info.iChannel))

 			iChannelMonitor->AddNewChannelL(info.iChannel);

 		}

 	CleanupStack::PopAndDestroy(); // array

 	}

 CNotifierManager::CNotifierManager()

 	{}

 void CNotifierManager::ConstructL()

 	{

 	iObservedList=new(ELeave) CArrayPtrSeg<MNotifierBase2>(6);

 	iLibraries=new(ELeave) CArrayFixFlat<RLibrary>(2);

 	iChannelMonitor=CChannelMonitor::NewL();

 	iActivityMonitor=CActivityMonitor::NewL();

 	iQueue=CNotifierQueue::NewL();

 	}

 struct SActivityCleanup

 	{

 	CActivityMonitor* iMonitor;

 	TUid iNotifier;

 	TInt iClientId;

 	};

 LOCAL_C void CleanupActivityMonitor(TAny* aPtr)

 	{

 	SActivityCleanup& cleanup=*REINTERPRET_CAST(SActivityCleanup*,aPtr);

 	cleanup.iMonitor->Remove(cleanup.iNotifier,cleanup.iClientId);

 	}

 void CNotifierManager::NotifierStartL(TUid aNotifierUid,const TDesC8& aBuffer,TPtrC8* aResponse,TInt aClientId)

 	{

 	TInt result=KErrNotFound;

 	const TInt count=iObservedList->Count();

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

 		{

 		MNotifierBase2* notif=(*iObservedList)[ii];

 		MNotifierBase2::TNotifierInfo info=notif->Info();

 		if (info.iUid==aNotifierUid)

 			{

 			if (iActivityMonitor->IsNotifierActive(aNotifierUid,info.iChannel))

 				{

 				result=KErrAlreadyExists;

 				}

 			else if (info.iPriority>iChannelMonitor->ActivityLevel(info.iChannel))

 				{

 				TUid notifier;

 				MNotifierBase2::TNotifierPriority priority;

 				const TBool channelWasActive=iActivityMonitor->IsChannelActive(info.iChannel,notifier,priority);

 				iActivityMonitor->AddL(info,aClientId);

 				SActivityCleanup cleanup;

 				cleanup.iMonitor=iActivityMonitor;

 				cleanup.iNotifier=aNotifierUid;

 				cleanup.iClientId=aClientId;

 				CleanupStack::PushL(TCleanupItem(CleanupActivityMonitor,&cleanup));

 				TPtrC8 response(notif->StartL(aBuffer));

 				if(aResponse)

 					aResponse->Set(response);

 				CleanupStack::Pop(); // cleanup;

 				if (channelWasActive)

 					{

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

 						{

 						MNotifierBase2* notifForUpdate=(*iObservedList)[ii];

 						MNotifierBase2::TNotifierInfo infoForUpdate=notifForUpdate->Info();

 						if (infoForUpdate.iUid==notifier && infoForUpdate.iChannel==info.iChannel)

 							{

 							TRAP_IGNORE(notifForUpdate->UpdateL(KNotifierPaused));

 							}

 						}

 					}

 				iChannelMonitor->UpdateChannel(info.iChannel,info.iPriority);

 				if (result!=ENotExtRequestQueued)

 					{

 					result=ENotExtRequestCompleted;

 					}

 				}

 			else

 				{

 				if (iQueue->IsAlreadyQueued(info.iUid,info.iChannel))

 					{

 					result=KErrAlreadyExists;

 					}

 				else

 					{

 					CQueueItem* queueCopy=CQueueItem::NewL(info,aBuffer,aClientId);

 					CleanupStack::PushL(queueCopy);

 					iQueue->QueueItemL(queueCopy);

 					CleanupStack::Pop(); // queueCopy

 					result=ENotExtRequestQueued;

 					}

 				}

 			}

 		}

 	User::LeaveIfError(result);

 	}

 TInt CNotifierManager::NotifierUpdateL(TUid aNotifierUid,const TDesC8& aBuffer,TDes8* aResponse,TInt aClientId)

 	{

 	TInt result=KErrNotFound;

 	const TInt count=iObservedList->Count();

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

 		{

 		MNotifierBase2* notif=(*iObservedList)[ii];

 		MNotifierBase2::TNotifierInfo info=notif->Info();

 		if (info.iUid==aNotifierUid)

 			{

 			if (iActivityMonitor->IsNotifierActive(aNotifierUid,info.iChannel))

 				{

 				if (!iActivityMonitor->IsClientPresent(aNotifierUid,info.iChannel,aClientId))

 					{

 					iActivityMonitor->AddL(info,aClientId);

 					}

 				if (aResponse==NULL)

 					{

 					notif->UpdateL(aBuffer);

 					}

 				else

 					{

 					aResponse->Copy(notif->UpdateL(aBuffer));

 					}

 				}

 			else

 				{

 				; // not all channels have been started yet so update the queue

 				}

 			result=KErrNone;

 			}

 		}

 	return result;

 	}

 void CNotifierManager::NotifierStartAndGetResponseL(TUid aNotifierUid,const TDesC8& aBuffer,TInt aReplySlot,

 														  const RMessage2& aMessage,TInt aClientId,TBool& aCleanupComplete)

 	{

 	NotifierStartAndGetResponseL(aNotifierUid,TUid::Null(),aBuffer,aReplySlot,aMessage,aClientId,aCleanupComplete);

 	}

 void CNotifierManager::NotifierStartAndGetResponseL(TUid aNotifierUid,TUid aChannelUid,const TDesC8& aBuffer,TInt aReplySlot,

 														  const RMessage2& aMessage,TInt aClientId,TBool& aCleanupComplete)

 	{

 	TInt result=KErrNotFound;

 	const TInt count=iObservedList->Count();

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

 		{

 		MNotifierBase2* notif=(*iObservedList)[ii];

 		MNotifierBase2::TNotifierInfo info=notif->Info();

 		if (info.iUid==aNotifierUid && (aChannelUid==TUid::Null() || info.iChannel==aChannelUid))

 			{

 			if (iActivityMonitor->IsNotifierActive(aNotifierUid,info.iChannel))

 				{

 				notif->StartL(aBuffer,aReplySlot,aMessage); // asynch notifier can decide whether to support multiple clients

 				result=KErrNone;

 				}

 			else if (info.iPriority>iChannelMonitor->ActivityLevel(info.iChannel))

 				{

 				TUid notifier;

 				MNotifierBase2::TNotifierPriority priority;

 				const TBool channelWasActive=iActivityMonitor->IsChannelActive(info.iChannel,notifier,priority);

 				iActivityMonitor->AddL(info,aClientId);

 				SActivityCleanup activityCleanup;

 				activityCleanup.iMonitor=iActivityMonitor;

 				activityCleanup.iNotifier=aNotifierUid;

 				activityCleanup.iClientId=aClientId;

 				CleanupStack::PushL(TCleanupItem(CleanupActivityMonitor,&activityCleanup));

 				aCleanupComplete=EFalse;

 				// IMPORTANT, aMessage needs to be a full RMessage object until suport for V1 notifiers is removed

 				// I.e. until CNotifierBaseAdaptor is removed

 				notif->StartL(aBuffer,aReplySlot,aMessage);

 				CleanupStack::Pop(&activityCleanup);

 				if (channelWasActive)

 					{

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

 						{

 						MNotifierBase2* notifForUpdate=(*iObservedList)[ii];

 						MNotifierBase2::TNotifierInfo infoForUpdate=notifForUpdate->Info();

 						if (infoForUpdate.iUid==notifier && infoForUpdate.iChannel==info.iChannel)

 							{

 							TRAP_IGNORE(notifForUpdate->UpdateL(KNotifierPaused));

 							}

 						}

 					}

 				iChannelMonitor->UpdateChannel(info.iChannel,info.iPriority);

 				result=KErrNone;

 				}

 			else

 				{

 				if (iQueue->IsAlreadyQueued(info.iUid,info.iChannel))

 					{

 					result=KErrAlreadyExists;

 					}

 				else

 					{

 					CQueueItem* queueCopy=CQueueItem::NewL(info,aBuffer,aReplySlot,aMessage,aClientId);

 					CleanupStack::PushL(queueCopy);

 					iQueue->QueueItemL(queueCopy);

 					CleanupStack::Pop(queueCopy);

 					result=ENotExtRequestQueued;

 					}

 				}

 			}

 		}

 	User::LeaveIfError(result);

 	}

 TInt CNotifierManager::NotifierCancel(TUid aNotifierUid)

 	{

 	TInt result=KErrNotFound;

 	const TInt count=iObservedList->Count();

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

 		{

 		MNotifierBase2* notif=(*iObservedList)[ii];

 		MNotifierBase2::TNotifierInfo info=notif->Info();

 		if (info.iUid==aNotifierUid)

 			{

 			notif->Cancel();

 			iActivityMonitor->RemoveNotifier(aNotifierUid,info.iChannel);

 			MNotifierBase2::TNotifierPriority priority=MNotifierBase2::ENotifierPriorityLowest;

 			TUid notifier;

 			//check channel activity and get highest priority on channnel

 			if (iActivityMonitor->IsChannelActive(info.iChannel,notifier,priority))

 				{

 				//check if priority of a queued item on the same channel is

 				//greater 

 				MNotifierBase2::TNotifierPriority queuePriority=

 				(MNotifierBase2::TNotifierPriority)iQueue->GetHighestQueuePriority(info.iChannel);

 				if (queuePriority>priority)

 					{

 					iChannelMonitor->UpdateChannel(info.iChannel,MNotifierBase2::ENotifierPriorityLowest);

 					CQueueItem* next=iQueue->FetchItem(info.iChannel);

 					if (next)

 						{

 						TUid notif=next->iInfo.iUid;

 						TRAPD(err,StartFromQueueL(next));

 						if (err!=KErrNone)

 							{

 							NotifierCancel(notif);

 							}

 						}

 					 }

 					else

 					{

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

 						{

 						MNotifierBase2* notifForUpdate=(*iObservedList)[ii];

 						MNotifierBase2::TNotifierInfo infoForUpdate=notifForUpdate->Info();

 						if (infoForUpdate.iUid==notifier && infoForUpdate.iChannel==info.iChannel)

 							{

 							TRAP_IGNORE(notifForUpdate->UpdateL(KNotifierPaused));

 							}

 						}

 					iChannelMonitor->UpdateChannel(info.iChannel,priority);

 					}

 				}

 			else

 				{

 				iChannelMonitor->UpdateChannel(info.iChannel,MNotifierBase2::ENotifierPriorityLowest);

 				CQueueItem* next=iQueue->FetchItem(info.iChannel);

 				if (next)

 					{

 					TUid notif=next->iInfo.iUid;

 					TRAPD(err,StartFromQueueL(next));

 					if (err!=KErrNone)

 						{

 						NotifierCancel(notif);

 						}

 					}

 				}

 			result=KErrNone;

 			}

 		}

 	return result;

 	}

 struct SCleanupMessage

 	{

 	TBool* iDoCleanup;

 	RMessage2* iMessage;

 	};

 LOCAL_C void CleanupStartAndGetResponse(TAny* aPtr)

 	{

 	SCleanupMessage& cleanup=*REINTERPRET_CAST(SCleanupMessage*,aPtr);

 	if (cleanup.iDoCleanup)

 		{

 		cleanup.iMessage->Complete(KErrNoMemory);

 		}

 	}

 void CNotifierManager::StartFromQueueL(CQueueItem* aItem)

 	{

 	CleanupStack::PushL(aItem);

 	TPtr8 buffer=aItem->iBuffer->Des();

 	if (aItem->iAsynchronous)

 		{

 		SCleanupMessage cleanup;

 		TBool doCleanup=ETrue;

 		cleanup.iDoCleanup=&doCleanup;

 		cleanup.iMessage=&aItem->iMessage;

 		CleanupStack::PushL(TCleanupItem(CleanupStartAndGetResponse,&cleanup));

 		// IMPORTANT, aItem->iMessage needs to be a full RMessage object until suport for V1 notifiers is removed

 		// I.e. until CNotifierBaseAdaptor is removed

 		NotifierStartAndGetResponseL(aItem->iInfo.iUid,aItem->iInfo.iChannel,buffer,aItem->iReplySlot,aItem->iMessage,aItem->iClientId,doCleanup);

 		CleanupStack::Pop(&cleanup);

 		}

 	else

 		{

 		NotifierStartL(aItem->iInfo.iUid,buffer,NULL,aItem->iClientId);

 		}

 	CleanupStack::PopAndDestroy(); // aItem

 	CQueueItem* update=iQueue->FetchItem(aItem->iInfo.iChannel);

 	while (update)

 		{

 		CleanupStack::PushL(update);

 		NotifierUpdateL(update->iInfo.iUid,*update->iBuffer,NULL,update->iClientId);

 		CleanupStack::PopAndDestroy(); // update

 		update=iQueue->FetchItem(aItem->iInfo.iChannel);

 		}

 	}

 void CNotifierManager::HandleClientExit(TInt aClientId)

 	{

 	TUid notifier=KNullUid;

 	while (iActivityMonitor->NotifierForClient(notifier,aClientId))

 		{

 		const TInt count=iObservedList->Count();

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

 			{

 			MNotifierBase2* notif=(*iObservedList)[ii];

 			if (notif->Info().iUid==notifier)

 				{

 				NotifierCancel(notifier);

 				}

 			}

 		iActivityMonitor->Remove(notifier,aClientId);

 		}

 	iActivityMonitor->RemoveClient(aClientId);

 	iQueue->RemoveClient(aClientId);

 	}

 void CNotifierManager::StartNotifierL(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

 	{

 	TPtrC8 response(0,0);

 	NotifierStartL(aNotifierUid,aBuffer, &response,KNullClientId);

 	aResponse.Copy(response);

 	}

 void CNotifierManager::CancelNotifier(TUid aNotifierUid)

 	{

 	NotifierCancel(aNotifierUid);

 	}

 void CNotifierManager::UpdateNotifierL(TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

 	{

 	NotifierUpdateL(aNotifierUid,aBuffer,&aResponse,KNullClientId);

 	}

 //

 // class CChannelMonitor

 //

 CChannelMonitor* CChannelMonitor::NewL()

 	{

 	CChannelMonitor* self=new(ELeave) CChannelMonitor;

 	return self;

 	}

 TBool CChannelMonitor::AlreadyHasChannel(TUid aChannel)const

 	{

 	const TInt count=iMonitor.Count();

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

 		{

 		if (iMonitor[ii].iChannel==aChannel)

 			return ETrue;

 		}

 	return EFalse;

 	}

 TInt CChannelMonitor::ActivityLevel(TUid aChannel) const

 	{

 	const TInt count=iMonitor.Count();

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

 		{

 		TChannelActivity activity=iMonitor[ii];

 		if (activity.iChannel==aChannel)

 			return activity.iHighestPriorityRunning;

 		}

 	return 0;

 	}

 void CChannelMonitor::UpdateChannel(TUid aChannel,TInt aLevel)

 	{

 	const TInt count=iMonitor.Count();

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

 		{

 		TChannelActivity& activity=iMonitor[ii];

 		if (activity.iChannel==aChannel)

 			{

 			activity.iHighestPriorityRunning=aLevel;

 			break;

 			}

 		}

 	}

 CChannelMonitor::CChannelMonitor()

 	:iMonitor(3)

 	{}

 //

 // class CNotifierActivity

 //

 CNotifierActivity* CNotifierActivity::NewLC(const MNotifierBase2::TNotifierInfo& aInfo,TInt aClientId)

 	{ // static

 	CNotifierActivity* self=new(ELeave) CNotifierActivity(aInfo);

 	CleanupStack::PushL(self);

 	self->ConstructL(aClientId);

 	return self;

 	}

 CNotifierActivity::~CNotifierActivity()

 	{

 	iClientArray.Reset();

 	}

 TInt CNotifierActivity::Find(TInt aClientId) const

 	{

 	TInt index=KErrNotFound;

 	const TInt count=iClientArray.Count();

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

 		{

 		TInt clientId=iClientArray[ii];

 		if (clientId==aClientId)

 			{

 			index=ii;

 			break;

 			}

 		}

 	return index;

 	}

 CNotifierActivity::CNotifierActivity(const MNotifierBase2::TNotifierInfo& aInfo)

 	: iInfo(aInfo), iClientArray(1)

 	{}

 void CNotifierActivity::ConstructL(TInt aClientId)

 	{

 	iClientArray.AppendL(aClientId);

 	}

 //

 // class CActivityMonitor

 //

 CActivityMonitor* CActivityMonitor::NewL()

 	{ // static

 	CActivityMonitor* self=new(ELeave) CActivityMonitor();

 	return self;

 	}

 CActivityMonitor::~CActivityMonitor()

 	{

 	iMonitor.ResetAndDestroy();

 	}

 void CActivityMonitor::AddL(const MNotifierBase2::TNotifierInfo& aInfo,TInt aClientId)

 	{

 	const TInt index=Find(aInfo.iUid,aInfo.iChannel);

 	if (index==KErrNotFound)

 		{

 		CNotifierActivity* activity=CNotifierActivity::NewLC(aInfo,aClientId);

 		iMonitor.AppendL(activity);

 		CleanupStack::Pop(); // activity

 		}

 	else

 		{

 		iMonitor[index]->iClientArray.AppendL(aClientId);

 		}

 	}

 void CActivityMonitor::Remove(TUid aNotifierUid,TInt aClientId)

 	{

 	const TInt index=Find(aNotifierUid);

 	if (index!=KErrNotFound)

 		{

 		CNotifierActivity* activity=iMonitor[index];

 		const TInt clientIndex=activity->Find(aClientId);

 		if (clientIndex!=KErrNotFound)

 			{

 			if (activity->iClientArray.Count()==1)

 				{

 				delete activity;

 				iMonitor.Delete(index);

 				}

 			else

 				{

 				activity->iClientArray.Delete(index);

 				}

 			}

 		}

 	}

 void CActivityMonitor::RemoveNotifier(TUid aNotifierUid,TUid aChannel)

 	{

 	const TInt index=Find(aNotifierUid,aChannel);

 	if (index!=KErrNotFound)

 		{

 		delete iMonitor[index];

 		iMonitor.Delete(index);

 		}

 	}

 void CActivityMonitor::RemoveClient(TInt aClientId)

 	{

 	TInt ii=0;

 	while (ii<iMonitor.Count())

 		{

 		CNotifierActivity* ptr=iMonitor[ii];

 		TInt index=ptr->Find(aClientId);

 		if (index!=KErrNotFound)

 			{

 			ptr->iClientArray.Delete(index);

 			}

 		if (ptr->iClientArray.Count()==0)

 			{

 			iMonitor.Delete(ii);

 			}

 		else

 			{

 			++ii;

 			}

 		}

 	}

 TBool CActivityMonitor::IsNotifierActive(TUid aNotifierUid,TUid aChannel) const

 	{

 	const TInt index=Find(aNotifierUid,aChannel);

 	return (index!=KErrNotFound);

 	}

 TBool CActivityMonitor::IsClientPresent(TUid aNotifierUid,TUid aChannel,TInt aClientId) const

 	{

 	TBool found=EFalse;

 	const TInt index=Find(aNotifierUid,aChannel);

 	if (index!=KErrNotFound)

 		{

 		found=(iMonitor[index]->Find(aClientId)!=KErrNotFound);

 		}

 	return found;

 	}

 TBool CActivityMonitor::IsChannelActive(TUid aChannel,TUid& aNotifier,MNotifierBase2::TNotifierPriority& aHighestPriority) const

 	{

 	TBool ret=EFalse;

 	const TInt count=iMonitor.Count();

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

 		{

 		MNotifierBase2::TNotifierInfo info=iMonitor[ii]->iInfo;

 		if (info.iChannel==aChannel)

 			{

 			ret=ETrue;

 			if ((MNotifierBase2::TNotifierPriority)info.iPriority>aHighestPriority)

 				{

 				aNotifier=info.iUid;

 				aHighestPriority=(MNotifierBase2::TNotifierPriority)info.iPriority;

 				}

 			}

 		}

 	return ret;

 	}

 TBool CActivityMonitor::NotifierForClient(TUid& aNotifierUid,TInt aClientId) const

 	{

 	TBool isOnlyClient=EFalse;

 	aNotifierUid=KNullUid;

 	const TInt count=iMonitor.Count();

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

 		{

 		CNotifierActivity* ptr=iMonitor[ii];

 		if (ptr->Find(aClientId)!=KErrNotFound)

 			{

 			aNotifierUid=ptr->iInfo.iUid;

 			isOnlyClient=ptr->iClientArray.Count()==1;

 			break;

 			}

 		}

 	return isOnlyClient;

 	}

 CActivityMonitor::CActivityMonitor()

 	: iMonitor(1)

 	{}

 TInt CActivityMonitor::Find(TUid aNotifierUid) const

 	{

 	TInt index=KErrNotFound;

 	const TInt count=iMonitor.Count();

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

 		{

 		if (iMonitor[ii]->iInfo.iUid==aNotifierUid)

 			{

 			index=ii;

 			break;

 			}

 		}

 	return index;

 	}

 TInt CActivityMonitor::Find(TUid aNotifierUid,TUid aChannel) const

 	{

 	TInt index=KErrNotFound;

 	const TInt count=iMonitor.Count();

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

 		{

 		CNotifierActivity* ptr=iMonitor[ii];

 		if (ptr->iInfo.iUid==aNotifierUid && ptr->iInfo.iChannel==aChannel)

 			{

 			index=ii;

 			break;

 			}

 		}

 	return index;

 	}

 //

 // class CQueueItem

 //

 CQueueItem* CQueueItem::NewL(const MNotifierBase2::TNotifierInfo& aInfo,const TDesC8& aBuffer,

 									TInt aReplySlot,const RMessage2& aMessage,TInt aClientId) //Asynchronous

 	{

 	CQueueItem* self=new(ELeave) CQueueItem(aInfo);

 	CleanupStack::PushL(self);

 	self->ConstructL(aBuffer,aMessage,aClientId,aReplySlot);

 	CleanupStack::Pop(); // self

 	return self;

 	}

 CQueueItem* CQueueItem::NewL(const MNotifierBase2::TNotifierInfo& aInfo,const TDesC8& aBuffer,TInt aClientId) //synchronous

 	{

 	CQueueItem* self=new(ELeave) CQueueItem(aInfo);

 	CleanupStack::PushL(self);

 	self->ConstructL(aBuffer,aClientId);

 	CleanupStack::Pop(); // self

 	return self;

 	}

 CQueueItem::~CQueueItem()

 	{

 	delete iBuffer;

 	}

 CQueueItem::CQueueItem(const MNotifierBase2::TNotifierInfo& aInfo)

 	: iInfo(aInfo)

 	{}

 void CQueueItem::ConstructL(const TDesC8& aBuffer,TInt aClientId)

 	{

 	iBuffer=aBuffer.AllocL();

 	iClientId=aClientId;

 	iAsynchronous=EFalse;

 	}

 void CQueueItem::ConstructL(const TDesC8& aBuffer,const RMessage2& aMessage,TInt aClientId,TInt aReplySlot)

 	{

 	iBuffer=aBuffer.AllocL();

 	iAsynchronous=ETrue;

 	iMessage=aMessage;

 	iClientId=aClientId;

 	iReplySlot=aReplySlot;

 	}

 //

 // class CNotifierQueue

 //

 CNotifierQueue* CNotifierQueue::NewL()

 	{

 	CNotifierQueue* self=new(ELeave) CNotifierQueue;

 	return self;

 	}

 CQueueItem* CNotifierQueue::FetchItem(TUid aChannel)

 	{

 	CQueueItem* result=NULL;

 	const TInt count=iQueue.Count();

 	TInt priority=MNotifierBase2::ENotifierPriorityLowest-1;

 	TInt index=KErrNotFound;

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

 		{

 		CQueueItem* item=iQueue[ii];

 		if (item->iInfo.iChannel==aChannel && item->iInfo.iPriority>priority)

 			{

 			index=ii;

 			priority=item->iInfo.iPriority;

 			result=item;

 			}

 		}

 	if (index!=KErrNotFound)

 		{

 		iQueue.Delete(index);

 		}

 	return result;

 	}

 TBool CNotifierQueue::IsAlreadyQueued(TUid aNotifier,TUid aChannel) const

 	{

 	TBool ret=EFalse;

 	const TInt count=iQueue.Count();

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

 		{

 		CQueueItem* item=iQueue[ii];

 		if (item->iInfo.iUid==aNotifier && item->iInfo.iChannel==aChannel)

 			{

 			ret=ETrue;

 			break;

 			}

 		}

 	return ret;

 	}

 void CNotifierQueue::RemoveClient(TInt aClientId)

 	{

 	const TInt count=iQueue.Count();

 	for (TInt ii=count-1;ii>=0;ii--)

 		{

 		CQueueItem* item=iQueue[ii];

 		TInt clientId=item->iClientId;

 		if (clientId==aClientId)

 			{

 			iQueue.Delete(ii);

 			}

 		}

 	}

 TInt CNotifierQueue::GetHighestQueuePriority(TUid aChannel)

 	{

 	const TInt count=iQueue.Count();

 	TInt priority=MNotifierBase2::ENotifierPriorityLowest-1;

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

 		{

 		CQueueItem* item=iQueue[ii];

 		if (item->iInfo.iChannel==aChannel && item->iInfo.iPriority>priority)

 			{

 			priority=item->iInfo.iPriority;

 			}

 		}

 	return priority;

 	}

 void CWsActiveScheduler::New()

 //

 // Create and install the active scheduler.

 //

 	{

 	CWsActiveScheduler *pA=new CWsActiveScheduler;

 	__ASSERT_ALWAYS(pA!=NULL,Fault(ECreateScheduler));

 	CActiveScheduler::Install(pA);

 	}

 void CWsActiveScheduler::Error(TInt) const

 //

 // Called if any Run() method leaves.

 //

 	{

 	}

 TInt NotifierServerThread(TAny*)

 	{

 	CTrapCleanup* CleanUpStack=CTrapCleanup::New();

 	CWsActiveScheduler::New();

 	TRAP_IGNORE(CNotifierServer::NewL());

 	CNotifierSession::NotifierSemaphore.Signal();

 	CWsActiveScheduler::Start();

 	delete CleanUpStack;

 	return(0);

 	}

 _LIT(KLitKeyDataDllNameBase, "EKDATA");

 _LIT(TwoDigExt,".%02d");

 GLDEF_C TInt E32Main()

 	{

 	UserSvr::WsRegisterThread();

 	UserSvr::WsRegisterSwitchOnScreenHandling(ETrue);

 	User::SetProcessCritical(User::ESystemPermanent);

 	User::SetCritical(User::ESystemPermanent);

 	CWsActiveScheduler::New();

 	CWsServer::New();

 	CWsWindow::New();

 	CEvent::New();

 	KeyTranslator=CKeyTranslator::New();

 	if (!KeyTranslator)

 		Fault(ENoKeyboardTranslator);

 //  Change keyboard mapping according to information in the HAL

 //	This code is the same as WSERV

 	TInt keyboardIndex;

 	if (HAL::Get(HALData::EKeyboardIndex,keyboardIndex)==KErrNone)

 		{

 		TBuf<16> keyDataDllName(KLitKeyDataDllNameBase);

 		keyDataDllName.AppendFormat(TwoDigExt, keyboardIndex);

 		KeyTranslator->ChangeKeyData(keyDataDllName);

 		}

     KeyRepeat=new(ELeave) CKeyRepeat(CKeyRepeat::EKeyRepeatPriority);

 	TRAPD(r,KeyRepeat->ConstructL());

 	if (r!=KErrNone)

 		User::Panic(_L("KEYREPEAT"),r);

 #ifndef __WINS__

     if (UserSvr::TestBootSequence())

 		{

 		RDebug::Print(_L("WS_MAIN: TestBootSequence=TRUE, not loading ESHELL.EXE"));

 		}

 #else

     if (EmulatorAutoRun())

     	{	// don't start ESHELL if we used a self-bootstrapping EXE

     	}

 #endif

 	else

 		{

 		RProcess shell;

 		r=shell.Create(KShellProcessName, KShellCommandLine);

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

 		shell.Resume();

 		shell.Close();

 		}

 	RThread t;

 	r=CNotifierSession::NotifierSemaphore.CreateLocal(0);

 	if (r!=KErrNone)

 		Fault(ECreateNotifierSemaphore);

 	r=t.Create(_L("NotifierServer"),NotifierServerThread,KDefaultStackSize,0x2000,0x100000,NULL);

 	if (r!=KErrNone)

 		Fault(ECreateNotifierThread);

 	t.Resume();

 	CNotifierSession::NotifierSemaphore.Wait();

 	CWsActiveScheduler::Start();

 	UserSvr::ReleaseEventHook();

 	return(KErrNone);

 	}