--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commonuisupport/uikon/srvsrc/eiksrv.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,696 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+
+#include <e32uid.h>
+#include <e32hal.h>
+#include <c32comm.h>
+#include <s32file.h>
+#include <basched.h>
+#include <bautils.h>
+#include <barsread.h>
+#include <babackup.h>
+#include <centralrepository.h>
+#include <apasvst.h>
+#include <apgcli.h>
+#include <apgwgnam.h>
+#include <viewcli.h>
+#include <vwsappst.h>
+#include <fepbase.h>
+#include <eikenv.h>
+#include <eikdll.h>
+#include <eikrutil.h>
+#include <uiklaf/private/lafenv.h>
+#include <uiklafgt/eikpriv.rsg>
+#include <uiklaf/private/lafsrv.h>
+#include <eiksrv.h>
+#include <eiksrvs.h>
+#include <eiksvdef.h>
+#include <eikdebug.h>
+#include <s32mem.h>
+#include "EIKSVFTY.H"
+#include "EIKNFYSV.H"
+#include "EIKALSRV.H"
+#include "EIKSRV.PAN"
+#include "eiksrvsconsts.h"
+#include "../coresrc/eikdebugprefs.h"
+#include <graphics/cone/coedefkeys.h>
+#include "eikdefconst.h"
+
+
+/** Default snooze increment in minutes.
+@publishedPartner */
+EXPORT_C extern const TInt KEikAlarmDefaultSnoozeInMinutes = 9;  // must not be initialized in the same CPP file as used, or the compiler will optimize it out
+
+const TInt KBufferExpansionGranularity = 0x8;
+const TUid KUidPasswordMode = {0x1000012B};
+
+_LIT(KPanicClient,"EikSrv-client");
+GLDEF_C void Panic(TEikServPanic aPanic)
+	{
+	_LIT(KPanicCat,"EIKON-SERVER");
+	User::Panic(KPanicCat,aPanic);
+	}
+
+const TUint KRangeCount = 2;
+const TInt KOpCodeRanges[KRangeCount] =
+	{
+	EFirstUnrestrictedOpcodeInEikAppUi,
+	EEikAppUiFirstUnusedOpcode,
+	};
+
+const TUint8 KElementsIndex[KRangeCount] =
+	{
+	CPolicyServer::EAlwaysPass, 	//Always passing no capability required  0-99
+	CPolicyServer::ENotSupported, 	//Not Supported		EEikAppUiFirstUnusedOpcode-End
+	};
+
+const CPolicyServer::TPolicy KEikServAppUiPolicy =
+	{
+	CPolicyServer::EAlwaysPass,
+	KRangeCount,
+	KOpCodeRanges,
+	KElementsIndex,
+	NULL
+	};
+
+//
+// class CEikServAppUiServer
+//
+
+EXPORT_C CEikServAppUiServer* CEikServAppUiServer::NewL()
+	{
+	CEikServAppUiServer *pS=new CEikServAppUiServer();
+    __ASSERT_ALWAYS(pS!=NULL,PanicServer(EEikSrvSvrCreateServer));
+	CleanupStack::PushL(pS);
+	pS->ConstructL();
+	pS->StartL(EIKAPPUI_SERVER_NAME);
+	CleanupStack::Pop();
+	static_cast<CEikServEnv*>(CEikonEnv::Static())->SetEikServer(pS);
+	return pS;
+	}
+
+const TInt KEiksrvUiDllValue = 0x100053D0;
+
+/** Creates an interface object to Eikon server.
+
+@publishedPartner
+@released
+*/
+typedef CEikAppUi* (*CreateCEikServAppUiBase)();
+
+void CEikServAppUiServer::ConstructL()
+	{
+	CEikonEnv& eikonEnv=*CEikonEnv::Static();
+	if (eikonEnv.WsSession().FindWindowGroupIdentifier(0,__EIKON_SERVER_NAME,0)==KErrNotFound)
+		{
+		// read the default FEP configuration from resource-file
+		TResourceReader resourceReader;
+		eikonEnv.CreateResourceReaderLC(resourceReader, R_EIK_FEP_DEFAULT_DATA);
+		const TPtrC defaultFep(resourceReader.ReadTPtrC());
+		const TUint onKeyCharacterCodeForFoldedMatch = resourceReader.ReadUint32();
+		const TUint onKeyModifierMask = resourceReader.ReadUint32();
+		const TUint onKeyModifierValues = resourceReader.ReadUint32();
+		const TUint offKeyCharacterCodeForFoldedMatch = resourceReader.ReadUint32();
+		const TUint offKeyModifierMask = resourceReader.ReadUint32();
+		const TUint offKeyModifierValues = resourceReader.ReadUint32();
+		const TBool onState = resourceReader.ReadUint8();
+		
+		// write the "ERepositoryKeyMask_DefaultSetting" settings to the KUidFepFrameworkRepository repository
+		CRepository* const repository = CRepository::NewLC(TUid::Uid(KUidFepFrameworkRepository));
+		User::LeaveIfError(repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction));
+		repository->CleanupCancelTransactionPushL();
+		CFepGenericGlobalSettings::WriteOnStateAndBroadcastL(*repository, onState, ERepositoryKeyMask_DefaultSetting);
+		User::LeaveIfError(repository->Set(ERepositoryKey_DefaultFepId, defaultFep));
+		CFepGenericGlobalSettings::WriteOnOrOffKeyDataAndBroadcastL(*repository, TFepOnOrOffKeyData(onKeyCharacterCodeForFoldedMatch, onKeyModifierMask, onKeyModifierValues), ERepositoryKey_DefaultOnKeyData);
+		CFepGenericGlobalSettings::WriteOnOrOffKeyDataAndBroadcastL(*repository, TFepOnOrOffKeyData(offKeyCharacterCodeForFoldedMatch, offKeyModifierMask, offKeyModifierValues), ERepositoryKey_DefaultOffKeyData);
+		CleanupStack::Pop(); // repository->CleanupCancelTransactionPushL
+		TUint32 notUsed = 0;
+		User::LeaveIfError(repository->CommitTransaction(notUsed)); // should never leave with KErrLocked as the "ERepositoryKeyMask_DefaultSetting" settings are only ever written to here
+		CleanupStack::PopAndDestroy(repository);
+		CleanupStack::PopAndDestroy(); // resourceReader
+		
+		// Try to load Fepswitch.exe
+		RProcess fepswitchProcess;
+		_LIT(KLitFepswitchExe, "z:\\sys\\bin\\Fepswitch.exe");
+		const TInt fepSwitchLoadErr = fepswitchProcess.Create(KLitFepswitchExe, KNullDesC, TUidType(TUid::Uid(0x1000007a), TUid::Null(), TUid::Uid(0x10272617)));
+		if(fepSwitchLoadErr != KErrNotFound)	// Fail silently if optional component fepswitch.exe does not exist
+			{
+			User::LeaveIfError(fepSwitchLoadErr);			
+			CleanupClosePushL(fepswitchProcess);
+			TRequestStatus requestStatus;
+			fepswitchProcess.Rendezvous(requestStatus);
+			fepswitchProcess.Resume();
+			User::WaitForRequest(requestStatus);
+			User::LeaveIfError(requestStatus.Int());
+			CleanupStack::PopAndDestroy(&fepswitchProcess);
+			}
+
+		// load the UI-specific DLL into the Eiksrvs process
+		TParse parse;
+		_LIT(KEiksrvUiDllName,"\\sys\\bin\\EiksrvUi.dll");
+		TFileName myDrive;
+		Dll::FileName(myDrive); // we want the drive-component, in order to load EiksrvUi.dll from the same drive as we're on
+		User::LeaveIfError(parse.SetNoWild(KEiksrvUiDllName,&myDrive,NULL));
+		TUidType uidType(KDynamicLibraryUid,KSharedLibraryUid,TUid::Uid(KEiksrvUiDllValue));
+		RLibrary lib;
+		User::LeaveIfError(lib.Load(KEiksrvUiDllName,parse.FullName(),uidType));
+		CleanupClosePushL(lib);
+		CreateCEikServAppUiBase appUi = (CreateCEikServAppUiBase)lib.Lookup(1);
+		CEikAppUi* self = (*appUi)();
+		User::LeaveIfNull(self);
+		static_cast<CEikServEnv&>(eikonEnv).SetUiDll(lib);
+		CleanupStack::Pop(); // lib
+		self->ConstructL(); // no leaving function may between the creation of "self" and this ConstructL call, as ownership of "this" is transferred to the CCoeEnv at the *start* of CEikServAppUiBase::ConstructL (hence also why "CleanupStack::PushL(self)" is not and should not be done)
+		
+		//create CEikDebugPreferences object
+		iDebugPreferences = CEikDebugPreferences::NewL();
+		TRAP_IGNORE(iDebugPreferences->RestoreL(eikonEnv.FsSession()));
+#if defined (_DEBUG) // debug keys are always on, in debug target
+		iDebugPreferences->SetFlags(iDebugPreferences->Flags()|CEikDebugPreferences::EFlagDebugKeysOn);
+#endif
+		}
+	}
+	
+CEikServAppUiServer::~CEikServAppUiServer()
+	{
+	delete iDebugPreferences;
+	}
+
+CSession2* CEikServAppUiServer::NewSessionL(const TVersion &aVersion,const RMessage2&) const
+	{
+	const TVersion version(1,0,0);
+	if (!User::QueryVersionSupported(version,aVersion))
+		User::Leave(KErrNotSupported);
+
+	const CEikServEnv* env = static_cast<CEikServEnv*>(CEikonEnv::Static());	
+	MEikServAppUiSessionFactory* factory = env->EikServAppUiSessionFactory();
+	return (factory ? factory->CreateSessionL() : NULL);
+	}
+
+CEikServAppUiServer::CEikServAppUiServer (TInt aPriority)
+ 	:CPolicyServer(aPriority, KEikServAppUiPolicy)
+	{}
+	
+CEikAppUi& CEikServAppUiServer::AppUi()
+	{
+	return *iAppUi;
+	}
+
+//
+// class CEikServAppUiSession
+//
+
+EXPORT_C CEikServAppUiSession::CEikServAppUiSession(MEikServAppUiSessionHandler* aHandler)
+	{
+	iSessionHandler=aHandler;
+	}
+
+EXPORT_C CEikServAppUiSession::~CEikServAppUiSession()
+	{
+	if(iScreenBlanked && iAppUiServer && iAppUiServer->iAppUi && iSessionHandler)
+		iSessionHandler->UnblankScreen();
+	}
+	
+EXPORT_C void CEikServAppUiSession::ConstructL()
+	{
+	}
+
+void CEikServAppUiSession::PanicClient(const RMessage2& aMessage, TEikAppUiServPanic aCode)
+	{
+	aMessage.Panic(KPanicClient, aCode);
+	}
+
+
+EXPORT_C MEikServAppUiSessionHandler* CEikServAppUiSession::SessionHandler() const
+	{
+	return iSessionHandler;
+	}		
+
+EXPORT_C void CEikServAppUiSession::ServiceL(const RMessage2 &aMessage)
+	{
+	ASSERT(iSessionHandler);
+	TBool completeMessage = ETrue;
+	TInt err = KErrNone;
+	switch (aMessage.Function())
+		{
+	case EEikAppUiCycleTasks:
+		iSessionHandler->CycleTasksL(TTaskCycleDirection(aMessage.Int0()));
+		break;
+	case EEikAppUiSetStatusPaneFlags:
+		iSessionHandler->SetStatusPaneFlags(aMessage.Int0());
+		break;
+	case EEikAppUiSetStatusPaneLayout:
+		TRAP(err, iSessionHandler->SetStatusPaneLayoutL(aMessage.Int0()));
+		// Complete with error locally before the break
+		completeMessage=EFalse;
+		aMessage.Complete(err);
+		break;
+	case EEikAppUiBlankScreen:
+        {
+        TRAP(err, iSessionHandler->BlankScreenL());
+		if (err == KErrNone)
+			iScreenBlanked = ETrue;
+        completeMessage = EFalse;
+		aMessage.Complete(err);
+        }
+		break;
+	case EEikAppUiUnblankScreen:
+		iSessionHandler->UnblankScreen();
+		iScreenBlanked=EFalse;
+		break;
+	case EEikAppUiEnableTaskList:
+		iSessionHandler->EnableTaskListL();
+		break;
+	case EEikAppUiLaunchTaskList:
+		iSessionHandler->LaunchTaskListL();
+		break;
+	case EEikAppUiResolveError:
+		{
+		const TInt errCode=aMessage.Int1();
+		const TUid appUid=TUid::Uid(aMessage.Int2());
+		TBuf<KEikErrorResolverMaxTextLength> errText;
+		const CEikonEnv::TErrorValidity errValidity=CEikonEnv::Static()->GetErrorText(errText,errCode,appUid);
+		if (errValidity==CEikonEnv::EErrorNumValid) 
+			aMessage.WriteL(0,errText);
+
+		aMessage.Complete(errValidity); 
+		break;
+		}
+	case EEikAppUiExtension: 
+		{
+		volatile TBool weAreResponsibleForCompletingMessage=ETrue;
+		TRAPD(error,
+			const TInt lengthOfRemoteBuffer=User::LeaveIfError(aMessage.GetDesLength(1));
+			TPtr8 buffer(NULL,0);
+			if (lengthOfRemoteBuffer>0)
+				{
+				buffer.Set(HBufC8::NewLC(lengthOfRemoteBuffer)->Des());
+				aMessage.ReadL(1, buffer);
+				}
+
+			weAreResponsibleForCompletingMessage=EFalse; // the CEikServAppUiBase-derived class here takes responsibility for completing (or panicking) the message, either in its Extension function or later (asynchronously)	
+			iSessionHandler->Extension(TUid::Uid(aMessage.Int0()),buffer,aMessage);
+			if (lengthOfRemoteBuffer>0)
+				CleanupStack::PopAndDestroy(); // the HBufC8
+			);
+
+		if(!weAreResponsibleForCompletingMessage)
+			completeMessage = EFalse;
+		else
+			{
+			if (error==KErrBadDescriptor)
+				aMessage.Panic(__EIKON_SERVER,EEikServPanicNotifyBadDescriptor);
+			else
+				aMessage.Complete(error);
+			}
+		}
+		break;
+	case EEikAppUiGetDebugPreferences:
+		{
+		CEikDebugPreferences* debugPreferences = Server().iDebugPreferences;
+		CBufFlat* const buffer = CBufFlat::NewL(KBufferExpansionGranularity);
+		CleanupStack::PushL(buffer);
+		RBufWriteStream writeStream(*buffer);
+		CleanupClosePushL(writeStream);
+		writeStream << *debugPreferences;
+		writeStream.CommitL();
+		
+		const TInt initialBufSize = aMessage.Int0();
+		if (initialBufSize && (buffer->Size() > initialBufSize))
+			{
+			// default buffer provided by client is too small, ask client to provide buffer of correct size
+			User::Leave(buffer->Ptr(0).Size());
+			}		
+		aMessage.WriteL(1, buffer->Ptr(0));
+		CleanupStack::PopAndDestroy(2); //writeStream & buffer
+		}
+		break;	
+	case EEikAppUiResolveErrorWithTitleText:
+		{
+		const TInt errCode=aMessage.Int1();
+
+		TErrorFlagAndId errInfo;
+		TPckg<TErrorFlagAndId> errInfoPackage(errInfo);
+		aMessage.ReadL(2, errInfoPackage);
+
+		const TInt lengthOfErrorTextBuffer = aMessage.GetDesMaxLengthL(0);
+		const TInt lengthOfTitleBuffer = aMessage.GetDesMaxLengthL(3);
+		
+		RBuf errText;
+		errText.CreateL(lengthOfErrorTextBuffer);
+		CleanupClosePushL(errText);
+
+		RBuf errorTitleText;
+		errorTitleText.CreateL(lengthOfTitleBuffer);
+		CleanupClosePushL(errorTitleText);
+
+		const CEikonEnv::TErrorValidity errValidity = CEikonEnv::Static()->DoGetErrorTextAndTitle(errText, errCode, errInfo.iTextId, errInfo.iFlags, errorTitleText, errInfo.iIsMemoryAllocatedByErrResolver);
+		if (errValidity == CEikonEnv::EErrorNumValid) 
+			{
+			aMessage.WriteL(0, errText);
+			aMessage.WriteL(3, errorTitleText);
+			}
+
+		CleanupStack::PopAndDestroy(2, &errText);
+		aMessage.WriteL(2, TPckg<TErrorFlagAndId>(errInfo));
+		aMessage.Complete(errValidity); 
+		break;
+		}
+
+	default:
+		aMessage.Complete(KErrNotSupported);
+		break;
+		}
+		
+	if (completeMessage && !aMessage.IsNull())
+		aMessage.Complete(KErrNone);
+	}
+
+
+EXPORT_C void CEikServAppUiSession::ServiceError(const RMessage2& aMessage,TInt aError)
+	{
+	if (!aMessage.IsNull())
+		{
+		switch(aError)
+			{
+		case KErrBadDescriptor:
+			PanicClient(aMessage, EEikSrvBadDescriptor);
+			break;
+		default:
+			aMessage.Complete(aError);
+			break;
+			}
+		}
+	}
+		
+	
+// Panic the server
+GLDEF_C void PanicServer(TEikAppUiServPanic aPanic)
+	{
+	_LIT(KPanicCat,"EikAppUiServer");
+	User::Panic(KPanicCat,aPanic);
+	}
+
+//
+// CEikPasswordModeCategory
+//
+
+/**  Constructs a new password mode category object. 
+
+The system's ini file (c:\\system\\system.ini) is opened, or created if it does not 
+already exist. 
+
+@param aFs A file server session.
+@return The new password mode category object, or NULL if the disk is full. */
+EXPORT_C CEikPasswordModeCategory* CEikPasswordModeCategory::NewLC(RFs& aFs)
+	{ // static
+	CEikPasswordModeCategory* self=new(ELeave) CEikPasswordModeCategory();
+	CleanupStack::PushL(self);
+	TRAPD(err, self->ConstructL(aFs));
+	if( err == KErrDiskFull )
+		{
+		CleanupStack::PopAndDestroy( self );
+		return NULL;
+		}
+	else if( err != KErrNone )
+		User::Leave( err );
+	
+	return self;
+	}
+
+/**  Destructor. Deletes the file store used to read and write the password mode. */
+EXPORT_C CEikPasswordModeCategory::~CEikPasswordModeCategory()
+	{
+	delete iStore;
+	}
+
+/** Reads the password mode entry from the system.ini file, if it contains such an entry, 
+and returns it in aMode.
+
+@param aMode On return, the system's password mode.*/
+EXPORT_C void CEikPasswordModeCategory::GetPasswordModeL(TPasswordMode& aMode) const
+	{
+	if(iStore && iStore->IsPresentL(KUidPasswordMode))
+		{
+		RDictionaryReadStream stream;
+		stream.OpenLC(*iStore,KUidPasswordMode);
+		aMode = static_cast<TPasswordMode>(stream.ReadInt32L());
+		CleanupStack::PopAndDestroy(); // stream
+		}
+	}
+
+/**  Sets the system's password mode by writing the value specified in aMode 
+to the system.ini file. 
+
+@param aMode The new value for the system's password mode. */
+EXPORT_C void CEikPasswordModeCategory::SetPasswordModeL(TPasswordMode aMode)
+	{
+	if(iStore)
+		{
+		RDictionaryWriteStream stream;
+		stream.AssignLC(*iStore,KUidPasswordMode);
+		stream.WriteInt32L(aMode);
+		stream.CommitL();
+		CleanupStack::PopAndDestroy(); // stream
+		iStore->CommitL();
+		}
+	}
+
+CEikPasswordModeCategory::CEikPasswordModeCategory()
+	{}
+
+void CEikPasswordModeCategory::ConstructL(RFs& aFs)
+	{
+	iStore=CDictionaryFileStore::SystemL(aFs);
+	}
+
+//
+// class CEikServEnv
+//
+
+EXPORT_C CEikServEnv::CEikServEnv()
+	{
+	iIsTaskListEnabled = !(LafEnv::IsTaskListDisabledAtInitialization());
+	}
+
+EXPORT_C CEikServEnv::~CEikServEnv()
+	{
+	iUiDll.Close();
+	}
+
+EXPORT_C void CEikServEnv::DestroyEnvironment()
+	{
+	delete iServer;
+	iServer = NULL;
+	CEikonEnv::DestroyEnvironment();
+	}
+
+void CEikServEnv::SetEikServer(CEikServAppUiServer* aServer)
+	{
+	iServer = aServer;
+	}
+
+EXPORT_C void CEikServEnv::SetUiDll(RLibrary& aDll)
+	{
+	iUiDll = aDll;
+	}
+
+/**  Sets the Eikon Server Session Factory. This must be called by the System GUI during startup.
+
+@param aSessionFactory a pointer to an object of an MEikServSessionFactory derived class. */
+EXPORT_C void CEikServEnv::SetEikServAppUiSessionFactory(MEikServAppUiSessionFactory* aSessionFactory)
+	{
+	ASSERT(iSessionFactory == NULL);
+	iSessionFactory = aSessionFactory;
+	}
+	
+/**  Returns the EikServ Session Factory.
+
+@return the EikServ Session Factory. */
+EXPORT_C MEikServAppUiSessionFactory* CEikServEnv::EikServAppUiSessionFactory() const
+	{
+	return iSessionFactory;
+	}
+
+/**  Returns the status of the task list.
+
+@return ETrue if the task list is enabled, EFalse if it is not. */
+EXPORT_C TBool CEikServEnv::IsTaskListEnabled() const
+	{
+	return iIsTaskListEnabled;
+	}
+
+/**  Enables the task list.
+*/
+EXPORT_C void CEikServEnv::EnableTaskList()
+	{
+	iIsTaskListEnabled = ETrue;
+	}
+
+
+//
+// MEikNotifyAlertCompletionObserver
+// 
+
+/** Constructor for MEikNotifyAlertCompletionObserver */
+EXPORT_C MEikNotifyAlertCompletionObserver::MEikNotifyAlertCompletionObserver()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void MEikNotifyAlertCompletionObserver::MEikNotifyAlertCompletionObserver_Reserved1()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void MEikNotifyAlertCompletionObserver::MEikNotifyAlertCompletionObserver_Reserved2()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::CEikServEnv_Reserved1()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::CEikServEnv_Reserved2()
+	{
+	}
+		
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::CEikServEnv_Reserved3()
+	{
+	}
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::CEikServEnv_Reserved4()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::CEikServEnv_Reserved5()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::CEikServEnv_Reserved6()
+	{
+	}
+
+// from CCoeEnv
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::Reserved_1()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void CEikServEnv::Reserved_2()
+	{
+	}
+
+		
+//
+// MEikServAppUiSessionHandler
+//
+
+EXPORT_C MEikServAppUiSessionHandler::MEikServAppUiSessionHandler()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void MEikServAppUiSessionHandler::MEikServAppUiSessionHandler_Reserved1()
+	{
+	}
+/** Reserved for future use */
+EXPORT_C void MEikServAppUiSessionHandler::MEikServAppUiSessionHandler_Reserved2()
+	{
+	}
+
+
+//
+// MEikServAppUiSessionFactory
+//
+
+EXPORT_C MEikServAppUiSessionFactory::MEikServAppUiSessionFactory()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void MEikServAppUiSessionFactory::MEikServAppUiSessionFactory_Reserved1()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void MEikServAppUiSessionFactory::MEikServAppUiSessionFactory_Reserved2()
+	{
+	}
+
+
+//
+// MEikServNotifyAlert
+// 
+
+/** Constructor for MEikServNotifyAlert */
+EXPORT_C MEikServNotifyAlert::MEikServNotifyAlert()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void MEikServNotifyAlert::MEikServNotifyAlert_Reserved1()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void MEikServNotifyAlert::MEikServNotifyAlert_Reserved2()
+	{
+	}
+
+//
+// MEikServAlarm
+// 
+
+/** Constructor for MEikServAlarm */
+EXPORT_C MEikServAlarm::MEikServAlarm()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void MEikServAlarm::MEikServAlarm_Reserved1()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void MEikServAlarm::MEikServAlarm_Reserved2()
+	{
+	}
+
+//
+// MEikServAlarmFactory
+// 
+
+/** Constructor for MEikServAlarmFactory */
+EXPORT_C MEikServAlarmFactory::MEikServAlarmFactory()
+	{
+	}
+
+/** Reserved for future use */
+EXPORT_C void MEikServAlarmFactory::MEikServAlarmFactory_Reserved1()
+	{
+	}
+	
+/** Reserved for future use */
+EXPORT_C void MEikServAlarmFactory::MEikServAlarmFactory_Reserved2()
+	{
+	}