diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/ConsoleAlarmAlertServer/Source/ConsoleAlarmAlertSession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commonappservices/alarmserver/ConsoleAlarmAlertServer/Source/ConsoleAlarmAlertSession.cpp	Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,1133 @@
+// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "ConsoleAlarmAlertSession.h"
+#include <e32svr.h>
+#include <asaltdefs.h>
+#include <test/consoleantestclient.h>
+#include "ConsoleAlarmAlertSession.h"
+#include "ConsoleAlarmAlertConsole.h"
+#include "ConsoleAlarmAlertLEDFlasher.h"
+#include "ConsoleAlarmAlertServer.h" //for inter-session communication
+
+const TInt KSlot0 = 0;
+const TInt KSlot1 = 1;
+const TInt KSlot2 = 2;
+
+
+// message -> string 
+
+static const TDesC& function_to_string(TInt function);
+
+CConsoleAlarmAlertSession::CConsoleAlarmAlertSession(CConsoleAlarmAlertServer* aServer)
+:	iServer(aServer), iInstructionSet(NULL), iInstructionSetFound(EFalse)
+	{
+	}
+
+CConsoleAlarmAlertSession::~CConsoleAlarmAlertSession()
+	{
+	CancelNotifications();
+	__FLOG_CLOSE;
+	
+	CConsoleAlarmAlertSession* session = iServer->WaitingSession();
+	session = NULL;
+	delete iSoundLEDFlasher;
+	delete iSoundCallbackTimer;
+	delete iConsole;
+	}
+
+void CConsoleAlarmAlertSession::ConstructL()
+	{
+	iSoundLEDFlasher = CConsoleAlarmAlertLEDFlasher::NewL();
+	iSoundCallbackTimer = CPeriodic::NewL(CActive::EPriorityIdle);
+	iConsole = new(ELeave) CConsoleAlarmAlertConsole(*this);
+	__FLOG_CONNECT;
+	__FLOG_CREATE(KLogFile, RFileFlogger::ELogModeAppend);
+	}
+
+CConsoleAlarmAlertSession* CConsoleAlarmAlertSession::NewL(CConsoleAlarmAlertServer* aServer)
+	{
+	CConsoleAlarmAlertSession* self = new(ELeave) CConsoleAlarmAlertSession(aServer);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+TTime CConsoleAlarmAlertSession::DeferTime() const
+	{
+	return iDeferTime;
+	}
+
+void CConsoleAlarmAlertSession::Notify(TASAltAlertServerResponse aFlag)
+	{
+	if	(iHasMessage)
+		{
+		TPckgC<TAlarmId> pId(iAlarm.Id());
+		TRAPD(err, iMsgPtr.WriteL(KSlot0, pId));
+		
+		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());
+		
+		iMsgPtr.Complete(aFlag);
+		iHasMessage = EFalse;
+		}
+	}
+
+void CConsoleAlarmAlertSession::Notify(TASAltAlertServerResponse aFlag, const TTime& aDeferTime)
+	{
+	if	(iHasMessage)
+		{	
+		TPckgC<TTime> time(aDeferTime);
+		TRAPD(err, iMsgPtr.WriteL(KSlot1, time));
+		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());
+
+		Notify(aFlag);
+		}
+	}
+
+void CConsoleAlarmAlertSession::ServiceL(const RMessage2& aMessage)
+	{
+	_LIT(KMsgFmt, "CConsoleAlarmAlertSession::ServiceL: Message: %s (%i) (0x%x 0x%x 0x%x 0x%x)");
+
+	__FLOG_INFO7(KMsgFmt, function_to_string(aMessage.Function()).Ptr(), aMessage.Function(), 
+				aMessage.Int0(), aMessage.Int1(), aMessage.Int2(), aMessage.Int3());
+	
+	if (iServer->IsExtendedMode()) 
+		{
+		if (MultiDispatchL(aMessage)) 
+			{
+			aMessage.Complete(KErrNone);
+			}
+		return;
+		}
+	
+	iMsgComplete = ETrue;
+	const TInt function = aMessage.Function();
+	
+	//see if the server holds a set of instructions to be followed,
+	//rather than waiting for user input.
+	if(!iInstructionSetFound) //go look for it now.
+		{
+		//we will enter into this code only once
+		const CServer2* tmpServ = Server();
+		const CConsoleAlarmAlertServer* specific = reinterpret_cast<const CConsoleAlarmAlertServer*>(tmpServ);
+		iInstructionSet = const_cast<CConsoleAlarmAlertServer*>(specific)->ResponseArray();
+		iInstructionSetFound = ETrue;
+		}
+
+	//
+	switch(function)
+		{
+	case EASAltTestOpCodeSetExtendedMode:
+		iServer->SetExtendedMode(ETrue);
+		iMsgComplete = ETrue;
+		break;
+		
+	case EASAltOpCodeGetMaxAlarms:
+		CmdGetMaxAlarmsL(aMessage);
+		iMsgComplete = ETrue;
+		break;
+		
+	case EASAltOpCodeDeleteAlarm:
+	case EASAltOpCodeDeleteAlarmAll:
+	case EASAltOpCodeVisibleAll:
+	case EASAltOpCodeSetStateAll:
+		iMsgComplete = ETrue;
+		break;
+		
+		
+    case EASAltOpCodeNotify:
+    	{
+		__ASSERT_ALWAYS(!iHasMessage, User::Invariant());
+		iMsgComplete = EFalse;
+		iMsgPtr = aMessage;
+		iHasMessage = ETrue;
+		iServer->SetWaitingSession(this);
+		iServer->SetNotifyMessage(&iMsgPtr);
+		break;
+		}
+
+    case EASAltOpCodeNotifyCancel:
+		if	(iHasMessage)
+			{
+			iHasMessage=EFalse;
+			iMsgPtr.Complete(KErrCancel);
+			iServer->SetNotifyMessage(NULL);
+			}
+		break;
+
+	case EASAltOpCodeVisible:
+		{
+		TBool isVisible = aMessage.Int0();
+		iConsole->SetVisibilityL(isVisible);
+		iServer->SetNotifying(isVisible);
+		break;
+		}
+
+    case EASAltOpCodeSetState:
+		iConsole->SetAlertStateL(aMessage.Int0());
+		break;
+
+    case EASAltOpCodeSetAlarm:
+		SetAlarmL(aMessage);
+		iConsole->iTimeInterval=0;
+		iConsole->UpdateDisplayL();
+		// Forces the Console to get response for the next alarm.
+		iConsole->CancelKey();
+		break;
+
+	case EASAltOpCodeGetUserTime:
+	case EASAltOpCodeGetEndQuietTime:
+		GetUserTimeL(aMessage);
+		break;
+
+	case EASAltOpCodeSetDeferTime:
+		SetDeferTimeL(aMessage);
+		iConsole->UpdateDisplayL();
+		break;
+
+    case EASAltOpCodeLogon:
+		__ASSERT_ALWAYS(!iLoggedOn, User::Invariant());
+		iMsgComplete=EFalse;
+		iLoggedOn=ETrue;
+		break;
+
+	case EASAltOpCodeStartPlayingSound:
+		{
+		iSoundLEDFlasher->Start();
+		TCallBack callback(SoundPlaybackCallbackL, this);
+		iSoundCallbackTimer->Start(TTimeIntervalMicroSeconds32(0), TTimeIntervalMicroSeconds32(3000000), callback);
+		break;
+		}
+
+	case EASAltOpCodeStopPlayingSoundAll: // Fallthrough
+	case EASAltOpCodeStopPlayingSound:
+		iSoundLEDFlasher->Stop();
+		iSoundCallbackTimer->Cancel();
+		break;
+
+//Test code
+	case EASAltTestOpCodeAcknowledgeAlarm:
+		if (iServer->WaitingSession())
+			iServer->WaitingSession()->Notify(EASAltAlertServerResponseClear);
+		break;
+
+	case EASAltTestOpCodeGetAttachment:
+		{
+		if (iServer->Attachment() != NULL)
+			{
+			const TDes8& data = iServer->Attachment()->Des();
+			const TInt maxLength = static_cast<TInt>(aMessage.Int0());
+			if	(data.Size() > maxLength)
+				User::Panic(_L("Client's buffer is too short"), KErrOverflow);
+			else
+				{
+				if (data.Length() == 0)
+					{
+					_LIT8(KEmpty,"Empty");
+					aMessage.WriteL(KSlot1, KEmpty);
+					}
+				else
+					{
+					aMessage.WriteL(KSlot1, data);
+					}
+				iServer->SetAttachment(NULL);
+				}
+			}
+		}
+		break;
+
+	case EASAltTestOpCodeGetIsNotifying:
+		{
+		TPckgC<TBool> ret = iServer->IsNotifying();
+		aMessage.WriteL(KSlot0, ret);
+		break;
+		}
+
+	default:
+		User::Invariant();
+		break;
+		}
+
+	if	(iMsgComplete)
+		aMessage.Complete(KErrNone);
+	}
+
+TBool CConsoleAlarmAlertSession::CmdL()
+	{
+	return KErrNone;
+	}
+
+void CConsoleAlarmAlertSession::ServiceError(const RMessage2 &aMessage, TInt aError)
+	{
+	_LIT(KErrFmt, "CConsoleAlarmAlertSession::ServiceError: Message: %s (0x%x, 0x%x, 0x%x, 0x%x) Error: %i");
+	__FLOG_INFO7(KErrFmt, function_to_string(aMessage.Function()).Ptr(), 
+				aMessage.Int0(), aMessage.Int1(), aMessage.Int2(), aMessage.Int3(),
+				aError); 
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+void CConsoleAlarmAlertSession::SetAlarmL(const RMessage2& aMessage)
+	{
+	TPckg<TASShdAlarm> pA(iAlarm);  
+	aMessage.ReadL(KSlot0, pA);
+	
+	   	//These lines will make sure the alert server is given the alarm in local time, if the alarm is set in local time (a floating alarm)
+  	if (iAlarm.IsFloating())  				
+  		{						
+  			TTimeIntervalSeconds offset = User::UTCOffset();
+  			if (iAlarm.NextDueTime() != Time::NullTTime())
+  			    {
+  			    iAlarm.NextDueTime() += offset;
+  			    }
+  			if (iAlarm.OriginalExpiryTime() != Time::NullTTime())
+  			    {
+  			    iAlarm.OriginalExpiryTime() += offset;
+  			    } 		
+  		}	
+	
+	
+	if	(iAlarm.HasAssociatedData())
+		{
+		//Storing the data in the server for the test session to read..
+		iAlarmAssociatedDataSize = aMessage.GetDesLengthL(2);
+		HBufC8* data = HBufC8::NewLC(iAlarmAssociatedDataSize);
+		TPtr8 pData(data->Des());
+		aMessage.ReadL(KSlot2, pData);
+		iServer->SetAttachment(data);  //Server takes an ownership
+		CleanupStack::Pop(data);
+		}
+	else
+		iAlarmAssociatedDataSize = 0;
+	}
+
+
+//*************************************************************************************
+void CConsoleAlarmAlertSession::GetUserTimeL(const RMessage2& aMessage)
+	{
+	TTime time;
+	time.UniversalTime();
+	time+=TTimeIntervalMinutes(iConsole->GetTimeInterval());
+	TPtrC8 pTime((TUint8 *)&time,sizeof(TTime));
+	aMessage.WriteL(KSlot0,pTime);
+	}
+
+
+//*************************************************************************************
+void CConsoleAlarmAlertSession::SetDeferTimeL(const RMessage2& aMessage)
+	{
+	TPckg<TTime> pTime(iDeferTime);
+	aMessage.ReadL(KSlot0, pTime);
+	}
+
+
+//*************************************************************************************
+TBool CConsoleAlarmAlertSession::SoundPlaybackCallbackL(TAny* /*aSelf*/)
+	{
+//	_LIT(KPlayingSound, "Playing sound");
+//	User::InfoPrint(KPlayingSound);
+	return ETrue;
+	}
+
+//**************************************************************************************
+TAny * CConsoleAlarmAlertSession::InstructionSet()
+	{
+	return iInstructionSet;
+	}
+	
+/**
+Completes the asynchronous EASAltTestOpCodeNotifyOnAlarm request.
+
+@param aAlarm, alarm received with the EASAltOpCodeSetAlarm message.
+@param aFullName, owner of the alarm.
+@param aData, any data attached with the EASAltOpCodeSetAlarm message.
+*/
+
+void CConsoleAlarmAlertSession::NotifyAlarmL(const TASShdAlarm& aAlarm, const TFullName& aFullName, const TDes8& aData)
+	{
+	TPckgC<TASShdAlarm> pAlarm(aAlarm);
+	
+	iAlarmNotify.WriteL(KSlot0, pAlarm);
+	
+	if (iAlarmNotify.Int1() != 0) 
+		{
+		iAlarmNotify.WriteL(KSlot1, aFullName);
+		}
+	
+	if (aData.Length() <= iAlarmNotify.GetDesLength(KSlot2))
+		{
+		iAlarmNotify.WriteL(KSlot2, aData);
+		}
+		
+	iAlarmNotify.Complete(KErrNone);
+	}
+
+/**
+Completes the asynchronous EASAltTestOpCodeNotifyOnSoundStart request.
+
+@param aId, id of alarm received with the EASAltOpCodeStartPlayingSound message.
+@param aFilename, name of sound file to play.
+*/
+
+void CConsoleAlarmAlertSession::NotifySoundStartL(const TAlarmId& aId, const TDesC& aFilename)
+	{
+	TPckgC<TAlarmId> pId(aId);
+	
+	iSoundStartNotify.WriteL(KSlot0, pId);
+	
+	if(aFilename.Length() <= iSoundStartNotify.GetDesLength(KSlot1))
+		{
+		iSoundStartNotify.WriteL(KSlot1, aFilename);
+		}
+	
+	iSoundStartNotify.Complete(KErrNone);
+	}
+
+/**
+Completes the asynchronous EASAltTestOpCodeNotifyOnSoundStop request.
+
+@param aId, id of alarm received with the EASAltOpCodeStopPlayingSound message.
+*/
+
+void CConsoleAlarmAlertSession::NotifySoundStopL(const TAlarmId& aId)
+	{
+	TPckgC<TAlarmId> pId(aId);
+	
+	iSoundStopNotify.WriteL(KSlot0, pId);
+	iSoundStopNotify.Complete(KErrNone);
+	}
+
+/**
+Completes the asynchronous EASAltTestOpCodeNotifyOnVisible request.
+
+@param aId, id of alarm received with the EASAltOpCodeVisible message.
+@param aVisible, visible status received with the EASAltOpCodeVisible message.
+*/
+
+void CConsoleAlarmAlertSession::NotifyVisibleL(const TAlarmId& aId, const TBool aVisible)
+	{
+	TPckgC<TAlarmId> pId(aId);
+	TPckgC<TBool> pVisible(aVisible);
+	
+	iVisibleNotify.WriteL(KSlot0, pId);
+	iVisibleNotify.WriteL(KSlot1, pVisible);
+	iVisibleNotify.Complete(KErrNone);
+	}
+
+/**
+Completes the asynchronous EASAltTestOpCodeNotifyOnState request.
+
+@param aId, id of alarm received with the EASAltOpCodeSetState message.
+@param aState, state received with the EASAltOpCodeSetState message.
+*/
+
+void CConsoleAlarmAlertSession::NotifyStateL(const TAlarmId& aId, const TInt aState)
+	{
+	TPckgC<TAlarmId> pId(aId);
+	TPckgC<TInt> pState(aState);
+	
+	iStateNotify.WriteL(KSlot0, pId);
+	iStateNotify.WriteL(KSlot1, pState);
+	iStateNotify.Complete(KErrNone);
+	}
+
+/**
+Completes the asynchronous EASAltTestOpCodeNotifyOnDelete request.
+
+@param aId, id of alarm received with the EASAltOpCodeDelete message.
+*/
+	
+void CConsoleAlarmAlertSession::NotifyDeleteL(const TAlarmId& aId)
+	{
+	TPckgC<TAlarmId> pId(aId);
+	
+	iDeleteNotify.WriteL(KSlot0, pId);
+	iDeleteNotify.Complete(KErrNone);
+	}
+
+/**
+When in multiple alarm mode this method handles the dispatching of messages.
+
+@param aMessage, the message to dispatch.
+@return ETrue if this message should be completed with KErrNone on return.
+		EFalse if this message shouldn't be completed on return.
+*/
+
+TBool CConsoleAlarmAlertSession::MultiDispatchL(const RMessage2& aMessage)
+	{
+	TBool complete = ETrue;
+	
+	switch(aMessage.Function())
+		{
+	case EASAltOpCodeNotify:
+		iMsgPtr = aMessage;
+		iServer->SetNotifyMessage(&iMsgPtr);
+		complete = EFalse;	
+		break;
+
+	case EASAltOpCodeNotifyCancel:
+		iServer->NotifyMessage()->Complete(KErrCancel);
+		iServer->SetNotifyMessage(NULL);
+		complete = EFalse;
+		break;
+
+	case EASAltOpCodeVisible:
+		CmdVisibleL(aMessage);
+		break;
+
+	case EASAltOpCodeSetState:
+		CmdSetStateL(aMessage);
+		break;
+		
+	case EASAltOpCodeSetAlarm:
+		CmdSetAlarmL(aMessage);
+		break;
+		
+	case EASAltOpCodeSetDeferTime:
+		CmdSetDeferTimeL(aMessage);
+		break;
+
+	case EASAltOpCodeGetEndQuietTime:
+	case EASAltOpCodeGetUserTime:
+		CmdGetUserTimeL(aMessage);
+		break;
+
+	case EASAltOpCodeLogon:
+		complete = EFalse;	
+		break;
+
+	case EASAltOpCodeStartPlayingSound:
+		CmdStartPlayingSoundL(aMessage);
+		break;
+
+	case EASAltOpCodeStopPlayingSound:
+		CmdStopPlayingSoundL(aMessage);
+		break;
+		
+	case EASAltOpCodeVisibleAll:
+	case EASAltOpCodeSetStateAll:
+	case EASAltOpCodeStopPlayingSoundAll:
+		break;
+		
+	case EASAltOpCodeDeleteAlarm:
+	case EASAltOpCodeDeleteAlarmAll:
+		CmdDeleteAlarmL(aMessage);
+		break;
+		
+	case EASAltOpCodeGetMaxAlarms:
+		CmdGetMaxAlarmsL(aMessage);
+		break;
+	
+	case EASAltTestOpCodeUnsetExtendedMode:
+		iServer->SetExtendedMode(EFalse);
+		break;
+		
+	case EASAltTestOpCodeSetExtendedMode: // Already in extended mode
+		break;
+			
+	case EASAltTestOpCodeSetUserTime:
+		CmdSetUserTimeL(aMessage);
+		break;
+				
+	case EASAltTestOpCodeSetMaxAlarms:
+		CmdSetMaxAlarmsL(aMessage);
+		break;
+	
+	case EASAltTestOpCodeNotifyOnAlarm:
+		CmdNotifyOnAlarmL(aMessage);
+		complete = EFalse;
+		break;
+		
+	case EASAltTestOpCodeNotifyOnSoundStart:
+		CmdNotifyOnSoundStartL(aMessage);
+		complete = EFalse;
+		break;
+		
+	case EASAltTestOpCodeNotifyOnSoundStop:
+		CmdNotifyOnSoundStopL(aMessage);
+		complete = EFalse;
+		break;
+		
+	case EASAltTestOpCodeNotifyOnVisible:
+		CmdNotifyOnVisibleL(aMessage);
+		complete = EFalse;
+		break;
+		
+	case EASAltTestOpCodeNotifyOnState:
+		CmdNotifyOnStateL(aMessage);
+		complete = EFalse;
+		break;
+		
+	case EASAltTestOpCodeNotifyOnDelete:
+		CmdNotifyOnDeleteL(aMessage);
+		complete = EFalse;
+		break;
+		
+	case EASAltTestOpCodeResponseSnoozeAlarm:
+		CmdResponseSnoozeAlarmL(aMessage);
+		break;
+		
+	case EASAltTestOpCodeResponseSilenceAlarm:
+		CmdResponseSilenceAlarmL(aMessage);
+		break;
+		
+	case EASAltTestOpCodeResponseAcknowledgeAlarm:
+		CmdResponseAcknowledgeAlarmL(aMessage);
+		break;
+		
+	case EASAltTestOpCodeResponsePauseSound:
+		CmdResponsePauseSoundL(aMessage);
+		break;
+		
+	case EASAltTestOpCodeCancelNotifications:
+		CancelNotifications();
+		break;
+	
+	case EASAltTestOpCodeResponseAcknowledgeAll:
+		CmdResponseAcknowledgeAll();
+		break;
+		
+	default:
+		User::Panic(_L("Unsupported op-code sent!"), KErrNotSupported);
+		}
+		
+	return complete;
+	}
+
+/**
+Sets the user time of the Console Alarm Alert Server.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdSetUserTimeL(const RMessage2& aMessage)
+	{
+	TTime time;
+	TPckg<TTime> pTime(time);
+	
+	aMessage.ReadL(KSlot0, pTime);
+	iServer->SetUserTime(time);
+	}
+
+/**
+Sets the max alarms value of the Console Alarm Alert Server.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdSetMaxAlarmsL(const RMessage2& aMessage)
+	{
+	TInt maxAlarms;
+	TPckg<TInt> pMaxAlarms(maxAlarms);
+	
+	aMessage.ReadL(KSlot0, pMaxAlarms);
+	
+	_LIT(KSetMaxFmt, "SetMaxAlarms: %i");
+	__FLOG_INFO2(KSetMaxFmt, maxAlarms);
+	
+	iServer->SetMaxAlarms(maxAlarms);
+	}
+
+/**
+Adds the session to the list of alarm observers.
+
+@param aMessage message to be completed when the asynchronous request is to be completed.
+*/
+
+void CConsoleAlarmAlertSession::CmdNotifyOnAlarmL(const RMessage2& aMessage)
+	{
+	if(!iAlarmNotify.IsNull())
+		{
+		aMessage.Complete(KErrInUse);
+		}
+
+	iAlarmNotify = aMessage;
+	iServer->AddObserverL(CConsoleAlarmAlertServer::EAlarmObserver, this);
+	}
+
+/**
+Adds the session to the list of sound start observers.
+
+@param aMessage message to be completed when the asynchronous request is to be completed.
+*/
+
+void CConsoleAlarmAlertSession::CmdNotifyOnSoundStartL(const RMessage2& aMessage)
+	{
+	if(!iSoundStartNotify.IsNull())
+		{
+		aMessage.Complete(KErrInUse);
+		}
+
+	iSoundStartNotify = aMessage;
+	iServer->AddObserverL(CConsoleAlarmAlertServer::ESoundStartObserver, this);
+	}
+
+/**
+Adds the session to the list of sound stop observers.
+
+@param aMessage message to be completed when the asynchronous request is to be completed.
+*/
+	
+void CConsoleAlarmAlertSession::CmdNotifyOnSoundStopL(const RMessage2& aMessage)
+	{
+	if(!iSoundStopNotify.IsNull())
+		{
+		aMessage.Complete(KErrInUse);
+		}
+
+	iSoundStopNotify = aMessage;
+	iServer->AddObserverL(CConsoleAlarmAlertServer::ESoundStopObserver, this);
+	}
+
+/**
+Adds the session to the list of visible observers.
+
+@param aMessage message to be completed when the asynchronous request is to be completed.
+*/
+	
+void CConsoleAlarmAlertSession::CmdNotifyOnVisibleL(const RMessage2& aMessage)
+	{
+	if(!iVisibleNotify.IsNull())
+		{
+		aMessage.Complete(KErrInUse);
+		}
+
+	iVisibleNotify = aMessage;
+	iServer->AddObserverL(CConsoleAlarmAlertServer::EVisibleObserver, this);
+	}
+	
+/**
+Adds the session to the list of state observers.
+
+@param aMessage message to be completed when the asynchronous request is to be completed.
+*/
+
+void CConsoleAlarmAlertSession::CmdNotifyOnStateL(const RMessage2& aMessage)
+	{
+	if(!iStateNotify.IsNull())
+		{
+		aMessage.Complete(KErrInUse);
+		}
+	
+	iStateNotify = aMessage;
+	iServer->AddObserverL(CConsoleAlarmAlertServer::EStateObserver, this);
+	}
+	
+void CConsoleAlarmAlertSession::CmdNotifyOnDeleteL(const RMessage2& aMessage)
+	{
+	if(!iDeleteNotify.IsNull())
+		{
+		aMessage.Complete(KErrInUse);
+		}
+		
+	iDeleteNotify = aMessage;
+	iServer->AddObserverL(CConsoleAlarmAlertServer::EDeleteObserver, this);
+	}
+	
+/**
+Completes the notify message with a EASAltAlertServerResponseSnooze response.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdResponseSnoozeAlarmL(const RMessage2& aMessage)
+	{
+	if (iServer->NotifyMessage())
+		{
+		TTime time;
+		TPckg<TTime> pTime(time);
+		aMessage.ReadL(KSlot1, pTime);
+
+		iServer->NotifyMessage()->WriteL(KSlot0, TPckgC<TAlarmId>(aMessage.Int0()));
+		iServer->NotifyMessage()->WriteL(KSlot1, pTime);
+		iServer->NotifyMessage()->Complete(EASAltAlertServerResponseSnooze);
+		iServer->SetNotifyMessage(NULL);
+		}
+	}
+	
+/**
+Completes the notify message with a EASAltAlertServerResponseSilence response.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdResponseSilenceAlarmL(const RMessage2& aMessage)
+	{
+	if (iServer->NotifyMessage())
+		{
+		iServer->NotifyMessage()->WriteL(KSlot0, TPckgC<TAlarmId>(aMessage.Int0()));
+		iServer->NotifyMessage()->Complete(EASAltAlertServerResponseSilence);
+		iServer->SetNotifyMessage(NULL);
+		}
+	}
+	
+/**
+Completes the notify message with a EASAltAlertServerResponseClear response.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdResponseAcknowledgeAlarmL(const RMessage2& aMessage)
+	{
+	if (iServer->NotifyMessage())
+		{
+		iServer->NotifyMessage()->WriteL(KSlot0, TPckgC<TAlarmId>(aMessage.Int0()));
+		iServer->NotifyMessage()->Complete(EASAltAlertServerResponseClear);
+		iServer->SetNotifyMessage(NULL);
+		}
+	}
+	
+/**
+Completes the notify message with a EASAltAlertServerResponsePauseSound response.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdResponsePauseSoundL(const RMessage2& aMessage)
+	{
+	if (iServer->NotifyMessage())
+		{
+		TTime time;
+		TPckg<TTime> pTime(time);
+		aMessage.ReadL(KSlot1, pTime);
+
+		iServer->NotifyMessage()->WriteL(KSlot0, TPckgC<TAlarmId>(aMessage.Int0()));
+		iServer->NotifyMessage()->WriteL(KSlot1, pTime);
+		iServer->NotifyMessage()->Complete(EASAltAlertServerResponsePauseSound);
+		iServer->SetNotifyMessage(NULL);
+		}
+	}
+
+/**
+Retrieves alarm, owner, any attached data and notifies all alarm observers.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdSetAlarmL(const RMessage2& aMessage)
+	{
+	TASShdAlarm alarm;
+	TPckg<TASShdAlarm> pAlarm(alarm);
+	aMessage.ReadL(KSlot0, pAlarm);
+	
+	TFullName name;
+	aMessage.ReadL(KSlot1, name);
+	
+	HBufC8 *buf = HBufC8::NewLC(aMessage.GetDesLengthL(KSlot2));
+	TPtr8 data(buf->Des());
+	aMessage.ReadL(KSlot2, data);
+	
+	TBuf<KMaxAlarmMessageLength + 1> msg(alarm.Message());
+	_LIT(KSetAlarmFmt, "Alarm id: %i message: %s");
+	__FLOG_INFO3(KSetAlarmFmt, alarm.Id(), msg.PtrZ());
+	
+	iServer->NotifyAlarmObserversL(alarm, name, data);
+	
+	CleanupStack::PopAndDestroy(buf);
+	}
+	
+/**
+Notifies all state observers.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdSetStateL(const RMessage2& aMessage)
+	{
+	iServer->NotifyStateObserversL(aMessage.Int1(), aMessage.Int0());
+	}
+	
+/**
+Notifies all visible observers.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdVisibleL(const RMessage2& aMessage)
+	{
+	iServer->NotifyVisibleObserversL(aMessage.Int1(), aMessage.Int0());
+	}
+	
+/**
+Retrieves sound file name and notifies all sound start observers.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdStartPlayingSoundL(const RMessage2& aMessage)
+	{
+	HBufC* buf = HBufC::NewLC(aMessage.GetDesLengthL(KSlot0) + 1);
+	TPtr data(buf->Des());
+	aMessage.ReadL(KSlot0, data);
+	
+	_LIT(KPlaySoundFmt, "Sound: %s");
+	__FLOG_INFO2(KPlaySoundFmt, data.PtrZ());
+	
+	iServer->NotifySoundStartObserversL(aMessage.Int1(), data);
+	
+	CleanupStack::PopAndDestroy(buf);
+	}
+
+/**
+Notifies all sound stop observers.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdStopPlayingSoundL(const RMessage2& aMessage)
+	{
+	iServer->NotifySoundStopObserversL(aMessage.Int0());
+	}
+	
+/**
+Logs the received defer time.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdSetDeferTimeL(const RMessage2& aMessage)
+	{
+	TTime time;
+	TPckg<TTime> pTime(time);
+	aMessage.ReadL(KSlot0, pTime);
+	
+	TBuf<32> buf;
+	time.FormatL(buf, _L("%Y:%M:%D - %H:%T:%S"));
+	_LIT(KDeferTimeFmt, "Set Defer Time: %s");
+	
+	__FLOG_INFO2(KDeferTimeFmt, buf.PtrZ());
+	}
+	
+/**
+Sends the Console Alarm Alert Server's user time.
+
+@param aMessage message to dispatch.
+*/
+
+void CConsoleAlarmAlertSession::CmdGetUserTimeL(const RMessage2& aMessage)
+	{
+	TBuf<32> buf;
+	iServer->UserTime().FormatL(buf, _L("%Y:%M:%D - %H:%T:%S"));
+	_LIT(KGetUserTimeFmt, "Get User Time: %s");
+	
+	__FLOG_INFO2(KGetUserTimeFmt, buf.PtrZ());
+	
+	TPckgC<TTime> pTime(iServer->UserTime());
+	aMessage.WriteL(KSlot0, pTime);
+	}
+	
+/**
+Cancels all outstanding notifications.
+*/	
+	
+void CConsoleAlarmAlertSession::CancelNotifications()
+	{
+	iServer->RemoveObserver(CConsoleAlarmAlertServer::EAlarmObserver, this);
+	iServer->RemoveObserver(CConsoleAlarmAlertServer::ESoundStopObserver, this);
+	iServer->RemoveObserver(CConsoleAlarmAlertServer::ESoundStartObserver, this);
+	iServer->RemoveObserver(CConsoleAlarmAlertServer::EVisibleObserver, this);
+	iServer->RemoveObserver(CConsoleAlarmAlertServer::EStateObserver, this);
+	iServer->RemoveObserver(CConsoleAlarmAlertServer::EDeleteObserver, this);
+
+	if(!iAlarmNotify.IsNull())
+		{
+		iAlarmNotify.Complete(KErrCancel);
+		}	
+	if(!iSoundStartNotify.IsNull())
+		{
+		iSoundStartNotify.Complete(KErrCancel);
+		}
+	if(!iSoundStopNotify.IsNull())
+		{
+		iSoundStopNotify.Complete(KErrCancel);
+		}
+	if(!iVisibleNotify.IsNull())
+		{
+		iVisibleNotify.Complete(KErrCancel);
+		}
+	if(!iStateNotify.IsNull())
+		{
+		iStateNotify.Complete(KErrCancel);
+		}
+	if(!iDeleteNotify.IsNull())
+		{
+		iDeleteNotify.Complete(KErrCancel);
+		}
+	}
+	
+/**
+Sends a EASAltAlertServerResponseClearAll to the Alarm Server.
+*/	
+	
+void CConsoleAlarmAlertSession::CmdResponseAcknowledgeAll()
+	{
+	if (iServer->NotifyMessage())
+		{
+		iServer->NotifyMessage()->Complete(EASAltAlertServerResponseClearAll);
+		iServer->SetNotifyMessage(NULL);
+		}
+	}
+	
+void CConsoleAlarmAlertSession::CmdGetMaxAlarmsL(const RMessage2& aMessage)
+	{
+	TPckg<TInt> pMax(iServer->MaxAlarms());
+	aMessage.WriteL(KSlot0, pMax);
+	}
+	
+void CConsoleAlarmAlertSession::CmdDeleteAlarmL(const RMessage2& aMessage)
+	{
+	if (aMessage.Function() == EASAltOpCodeDeleteAlarmAll)
+		{
+		iServer->NotifyDeleteObserversL(KNullAlarmId);
+		}
+	else
+		{
+		iServer->NotifyDeleteObserversL(aMessage.Int0());
+		}
+	}
+
+// Op-codes are from TASAltTestOpCode in ConsoleANTestClient.h
+
+_LIT(KOpCode0, "EASAltOpCodeNotify\0");
+_LIT(KOpCode1, "EASAltOpCodeVisible\0");
+_LIT(KOpCode2, "EASAltOpCodeSetState\0");
+_LIT(KOpCode3, "EASAltOpCodeSetAlarm\0");
+_LIT(KOpCode4, "EASAltOpCodeSetDeferTime\0");
+_LIT(KOpCode5, "EASAltOpCodeGetUserTime\0");
+_LIT(KOpCode6, "EASAltOpCodeLogon\0");
+_LIT(KOpCode7, "EASAltOpCodeStartPlayingSound\0");
+_LIT(KOpCode8, "EASAltOpCodeStopPlayingSound\0");
+_LIT(KOpCode9, "EASAltTestOpCodeAcknowledgeAlarm\0");
+_LIT(KOpCode10, "EASAltOpCodeVisibleAll\0");
+_LIT(KOpCode11, "EASAltOpCodeSetStateAll\0");
+_LIT(KOpCode12, "EASAltOpCodeStopPlayingSoundAll\0");	
+_LIT(KOpCode13, "EASAltOpCodeDeleteAlarm\0");
+_LIT(KOpCode14, "EASAltOpCodeGetEndQuietTime\0");	
+_LIT(KOpCode15, "EASAltOpCodeGetMaxAlarms\0");
+_LIT(KOpCode16, "EASAltTestOpCodeGetAttachment\0");
+_LIT(KOpCode17, "EASAltTestOpCodeGetIsNotifying\0");
+_LIT(KOpCode18, "EASAltTestOpCodeSetExtendedMode\0");
+_LIT(KOpCode19, "EASAltTestOpCodeUnsetExtendedMode\0");
+_LIT(KOpCode20, "EASAltTestOpCodeSetUserTime\0");
+_LIT(KOpCode21, "EASAltTestOpCodeSetMaxAlarms\0");
+_LIT(KOpCode22, "EASAltTestOpCodeNotifyOnAlarm\0");
+_LIT(KOpCode23, "EASAltTestOpCodeNotifyOnSoundStart\0");
+_LIT(KOpCode24, "EASAltTestOpCodeNotifyOnSoundStop\0");
+_LIT(KOpCode25, "EASAltTestOpCodeNotifyOnVisible\0");
+_LIT(KOpCode26, "EASAltTestOpCodeNotifyOnState\0");
+_LIT(KOpCode27, "EASAltTestOpCodeResponseSnoozeAlarm\0");
+_LIT(KOpCode28, "EASAltTestOpCodeResponseSilenceAlarm\0");
+_LIT(KOpCode29, "EASAltTestOpCodeResponseAcknowledgeAlarm\0");
+_LIT(KOpCode30, "EASAltTestOpCodeResponsePauseSound\0");
+_LIT(KOpCode31, "EASAltTestOpCodeCancelNotifications\0");
+_LIT(KOpCode32, "EASAltTestOpCodeResponseAcknowledgeAll\0");
+_LIT(KOpCode33, "EASAltTestOpCodeNotifyOnDelete\0");
+_LIT(KOpCode34, "EASAltOpCodeNotifyCancel\0");
+_LIT(KOpCode35, "EASAltOpCodeDeleteAlarmAll\0");
+_LIT(KUnknown, "Unknown op-code\0");
+
+/**
+Maps "op-codes" to textual description.
+@param function, "op-code" to map.
+@return textual description of "op-code".
+*/
+
+static const TDesC& function_to_string(TInt function)
+	{
+	switch(function)
+		{
+	case EASAltOpCodeNotify: 
+		return KOpCode0;
+	case EASAltOpCodeVisible: 
+		return KOpCode1;
+	case EASAltOpCodeSetState: 
+		return KOpCode2;
+	case EASAltOpCodeSetAlarm: 
+		return KOpCode3;
+	case EASAltOpCodeSetDeferTime: 
+		return KOpCode4;
+	case EASAltOpCodeGetUserTime: 
+		return KOpCode5;
+	case EASAltOpCodeLogon: 
+		return KOpCode6;
+	case EASAltOpCodeStartPlayingSound: 
+		return KOpCode7;
+	case EASAltOpCodeStopPlayingSound: 
+		return KOpCode8;
+	case EASAltTestOpCodeAcknowledgeAlarm: 
+		return KOpCode9;
+	case EASAltOpCodeVisibleAll:
+		return KOpCode10;
+	case EASAltOpCodeSetStateAll:
+		return KOpCode11;
+	case EASAltOpCodeStopPlayingSoundAll:
+		return KOpCode12;	
+	case EASAltOpCodeDeleteAlarm:
+		return KOpCode13;
+	case EASAltOpCodeGetEndQuietTime:
+		return KOpCode14;
+	case EASAltOpCodeGetMaxAlarms:
+		return KOpCode15;	
+	case EASAltTestOpCodeGetAttachment: 
+		return KOpCode16;
+	case EASAltTestOpCodeGetIsNotifying: 
+		return KOpCode17;
+	case EASAltTestOpCodeSetExtendedMode: 
+		return KOpCode18;
+	case EASAltTestOpCodeUnsetExtendedMode: 
+		return KOpCode19;
+	case EASAltTestOpCodeSetUserTime: 
+		return KOpCode20;
+	case EASAltTestOpCodeSetMaxAlarms: 
+		return KOpCode21;
+	case EASAltTestOpCodeNotifyOnAlarm: 
+		return KOpCode22;
+	case EASAltTestOpCodeNotifyOnSoundStart: 
+		return KOpCode23;
+	case EASAltTestOpCodeNotifyOnSoundStop: 
+		return KOpCode24;
+	case EASAltTestOpCodeNotifyOnVisible: 
+		return KOpCode25;
+	case EASAltTestOpCodeNotifyOnState: 
+		return KOpCode26;
+	case EASAltTestOpCodeResponseSnoozeAlarm: 
+		return KOpCode27;
+	case EASAltTestOpCodeResponseSilenceAlarm: 
+		return KOpCode28;
+	case EASAltTestOpCodeResponseAcknowledgeAlarm: 
+		return KOpCode29;
+	case EASAltTestOpCodeResponsePauseSound: 
+		return KOpCode30;
+	case EASAltTestOpCodeCancelNotifications:
+		return KOpCode31;
+	case EASAltTestOpCodeResponseAcknowledgeAll:
+		return KOpCode32;
+	case EASAltTestOpCodeNotifyOnDelete:
+		return KOpCode33;
+	case EASAltOpCodeNotifyCancel:
+		return KOpCode34;
+	case EASAltOpCodeDeleteAlarmAll:
+		return KOpCode35;
+	default:
+		return KUnknown;
+		}
+	}
+