diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Server/Source/ASSrvSession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commonappservices/alarmserver/Server/Source/ASSrvSession.cpp	Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,1561 @@
+// 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 "ASSrvSession.h"
+
+// System includes
+#include <s32mem.h>
+
+// User includes
+#include "ASShdPragma.h"
+#include "ASShdOpCodes.h"
+//
+#include "ASSrvTimer.h"
+#include "ASSrvAlarmQueue.h"
+#include "ASSrvStaticUtils.h"
+#include "ASSrvSessionEngine.h"
+#include "ASSrvSoundSettings.h"
+#include "ASSrvServerWideData.h"
+#include "ASSrvSoundController.h"
+#include "ASSrvAlarmSoundDetails.h"
+#include "ASSrvNotificationCoordinator.h"
+
+#ifdef _DEBUG
+#include "ASSrvEnvironmentChangeManager.h"
+#endif 
+
+// Type definitions
+
+// Constants
+const TInt KAlarmServerTransferBufferExpandSize = 100;
+const TInt KSlot0 = 0;
+const TInt KSlot1 = 1;
+const TInt KSlot2 = 2;
+
+// Enumerations
+
+// Classes referenced
+
+
+//
+// ----> CASSrvSession (source)
+//
+
+//*************************************************************************************
+CASSrvSession::CASSrvSession(CASSrvServerWideData& aServerWideData)
+:	iServerWideData(aServerWideData), iAlarmSink(aServerWideData)
+	{
+	}
+
+
+//*************************************************************************************
+CASSrvSession::~CASSrvSession()
+	{
+	HandleServerDestruction();
+	//
+	delete iTransferBuffer;
+	//
+	iChangeEventBuffer.Close();
+	}
+
+
+//*************************************************************************************
+void CASSrvSession::ConstructL()
+	{
+	iTransferBuffer = CBufFlat::NewL(KAlarmServerTransferBufferExpandSize);
+	iSessionEngine = CASSrvSessionEngine::NewL(ServerData(), *this, *this);
+	}
+
+
+//*************************************************************************************
+CASSrvSession* CASSrvSession::NewL(CASSrvServerWideData& aServerWideData)
+	{
+	CASSrvSession* self = new(ELeave) CASSrvSession(aServerWideData);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+/**
+ * Called by the server's destructor. We need to be told that the server is
+ * being destroyed, since the server owns the server-wide data, and this class
+ * must destroy the session engine (which will unregister for various notifications)
+ * using the server wide data instance.
+ */
+void CASSrvSession::HandleServerDestruction()
+	{
+	delete iSessionEngine;
+	iSessionEngine = NULL;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+/**
+ * @see MASSrvAnyEventObserver
+ */
+void CASSrvSession::MASSrvAnyEventHandleChange(TAlarmChangeEvent aEvent, TAlarmId aAlarmId)
+	{
+	CompleteChangeNotificationMessage(aEvent, aAlarmId);
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+/**
+ * @see MASSrvSession
+ *
+ * Facade to the real session
+ */
+TASSrvSessionId CASSrvSession::MASSrvSessionId() const
+	{
+	// This shouldn't ever be called
+	__ASSERT_DEBUG(EFalse, ASSrvStaticUtils::Fault(ASSrvStaticUtils::EASSrvFaultFacadeInterfaceError));
+	return KNullSessionId;
+	}
+
+
+//*************************************************************************************
+/**
+ * @see MASSrvSession
+ *
+ * Facade to the real session
+ */
+void CASSrvSession::MASSrvSessionFullName(TDes& aDes) const
+	{
+	aDes.Zero();
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+void CASSrvSession::ServiceL(const RMessage2& aMessage)
+	{
+	// Leave's are caught by CASSrvServer::RunError
+	iMessage=&aMessage;
+	const TBool completeMessage = DoServiceL();
+	if	(completeMessage)
+		aMessage.Complete(KErrNone);
+	iMessage=NULL;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::DoServiceL()
+	{
+	// Reset alarm sink to remove old data
+	iAlarmSink.Reset();
+
+	//
+	// POSSIBLY OPTIMISE THIS LOT INTO A LOOKUP TABLE?
+	//
+	TBool completeMessage = EFalse;
+	const TInt opCode = Message().Function();
+	//
+	switch(opCode)
+		{
+	//
+	// CMD - ALARM SPECIFIC FUNCTIONALITY
+	case EASShdOpCodeAlarmAdd:
+		completeMessage = CmdAlarmAddL();
+		break;
+	case EASShdOpCodeAlarmAddWithNotification:
+		completeMessage = CmdAlarmAddWithNotificationL();
+		break;
+	case EASShdOpCodeAlarmNotificationCancelAndDeQueue:
+		completeMessage = CmdAlarmNotificationCancelAndDeQueueL();
+		break;
+	case EASShdOpCodeGetAlarmDetails:
+		completeMessage = CmdGetAlarmDetailsL();
+		break;
+	case EASShdOpCodeAlarmDelete:
+		completeMessage = CmdAlarmDeleteL();
+		break;
+	case EASShdOpCodeGetAlarmCategory:
+		completeMessage = CmdGetAlarmCategoryL();
+		break;
+	case EASShdOpCodeGetAlarmOwner:
+		completeMessage = CmdGetAlarmOwnerL();
+		break;
+	case EASShdOpCodeSetAlarmStatus:
+		completeMessage = CmdSetAlarmStatusL();
+		break;
+	case EASShdOpCodeSetAlarmStatusForCalendarFile:
+        completeMessage = CmdSetAlarmStatusForCalendarFileL();
+        break;		
+	case EASShdOpCodeGetAlarmStatus:
+		completeMessage = CmdGetAlarmStatusL();
+		break;
+	case EASShdOpCodeSetAlarmDayOrTimed:
+		completeMessage = CmdSetAlarmDayOrTimedL();
+		break;
+	case EASShdOpCodeGetAlarmDayOrTimed:
+		completeMessage = CmdGetAlarmDayOrTimedL();
+		break;
+	case EASShdOpCodeGetAlarmCharacteristics:
+		completeMessage = CmdGetAlarmCharacteristicsL();
+		break;
+	case EASShdOpCodeSetAlarmCharacteristics:
+		completeMessage = CmdSetAlarmCharacteristicsL();
+		break;
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+	case EASShdOpCodeSetWakeup:
+		completeMessage = CmdSetWakeupL();
+		break;
+#endif
+#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS
+	case EASShdOpCodeGetAlarmDays:
+		completeMessage = CmdGetAlarmDaysL();
+		break;
+	case EASShdOpCodeSetAlarmDays:
+		completeMessage = CmdSetAlarmDaysL();
+		break;
+	case EASShdOpCodeSetContinuous:
+		completeMessage = CmdSetContinuousL();
+		break;
+	case EASShdOpCodeGetContinuous:
+		completeMessage = CmdContinuousL();
+		break;
+#endif
+	case EASShdOpCodeOrphanAlarm:
+		completeMessage = CmdOrphanAlarmL();
+		break;
+	case EASShdOpCodeSetClientData:
+		completeMessage = CmdSetClientDataL();
+		break;
+	//
+	// CMD - ALARM DATA FUNCTIONALITY
+	case EASShdOpCodeAlarmDataAttach:
+		completeMessage = CmdAlarmDataAttachL();
+		break;
+	case EASShdOpCodeAlarmDataDetach:
+		completeMessage = CmdAlarmDataDetachL();
+		break;
+	case EASShdOpCodeAlarmDataSize:
+		completeMessage = CmdAlarmDataSizeL();
+		break;
+	case EASShdOpCodeGetAlarmData:
+		completeMessage = CmdGetAlarmDataL();
+		break;
+	//
+	// CMD - CATEGORY-SPECIFIC FUNCTIONALITY
+	case EASShdOpCodeSetAlarmStatusByCategory:
+		completeMessage = CmdSetAlarmStatusByCategoryL();
+		break;
+	case EASShdOpCodeGetAlarmCountForCategory:
+		completeMessage = CmdGetAlarmCountForCategoryL();
+		break;
+	case EASShdOpCodeAlarmDeleteAllByCategory:
+		completeMessage = CmdAlarmDeleteAllByCategoryL();
+		break;
+	case EASShdOpCodeAlarmDeleteByCategory:
+		completeMessage = CmdAlarmDeleteByCategoryL();
+		break;
+	case EASShdOpCodeAlarmDeleteByCalendarFile:
+        completeMessage = CmdAlarmDeleteByCalendarFileL();
+        break;
+	case EASShdOpCodeGetAvailableCategoryList:
+		completeMessage = CmdGetAvailableCategoryListL();
+		break;
+	case EASShdOpCodeGetAlarmIdListForCategory:
+		completeMessage = CmdGetAlarmIdListForCategoryL();
+		break;
+	//
+	// CMD - MISC FUNCTIONALITY
+	case EASShdOpCodeAlarmCountByState:
+		completeMessage = CmdAlarmCountByStateL();
+		break;
+	case EASShdOpCodeGetAlarmIdListByState:
+		completeMessage = CmdGetAlarmIdListByStateL();
+		break;
+	case EASShdOpCodeGetAlarmIdList:
+		completeMessage = CmdGetAlarmIdListL();
+		break;
+	case EASShdOpCodeGetNextDueAlarmId:
+		completeMessage = CmdGetNextDueAlarmIdL();
+		break;
+	case EASShdOpCodeNumberOfAlarmsActiveInQueue:
+		completeMessage = CmdNumberOfActiveAlarmsInQueueL();
+		break;
+	//
+	// CMD - SOUND CONTROL
+	case EASShdOpCodeSetAlarmSoundState:
+		completeMessage = CmdSetAlarmSoundStateL();
+		break;
+	case EASShdOpCodeGetAlarmSoundState:
+		completeMessage = CmdGetAlarmSoundStateL();
+		break;
+	case EASShdOpCodeSetAlarmSoundsSilentUntil:
+		completeMessage = CmdSetAlarmSoundsSilentUntilL();
+		break;
+	case EASShdOpCodeSetAlarmSoundsSilentFor:
+		completeMessage = CmdSetAlarmSoundsSilentForL();
+		break;
+	case EASShdOpCodeGetAlarmSoundsSilentUntil:
+		completeMessage = CmdGetAlarmSoundsSilentUntilL();
+		break;
+	case EASShdOpCodeCancelAlarmSilence:
+		completeMessage = CmdCancelAlarmSilenceL();
+		break;
+	case EASShdOpCodeAlarmSoundsTemporarilySilenced:
+		completeMessage = CmdGetAlarmSoundsTemporarilySilencedL();
+		break;
+	case EASShdOpCodeSetAlarmPlayIntervals:
+		completeMessage = CmdSetAlarmPlayIntervalsL();
+		break;
+	case EASShdOpCodeGetAlarmPlayIntervals:
+		completeMessage = CmdGetAlarmPlayIntervalsL();
+		break;
+	//
+	// CMD - CHANGE NOTIFICATION
+	case EASShdOpCodeNotifyChange:
+		completeMessage = CmdNotifyChangeL();
+		break;
+	case EASShdOpCodeNotifyChangeCancel:
+		completeMessage = CmdNotifyChangeCancelL();
+		break;
+	//
+	// CMD - DEBUG ONLY
+	case EASShdOpCodeDbgShutDownServer:
+		completeMessage = CmdDbgShutDownServerL();
+		break;
+	case EASShdOpCodeDbgFailAlloc:
+		completeMessage = CmdDbgFailAllocL();
+		break;
+	case EASShdOpCodeDbgPreventUserNotify:
+		completeMessage = CmdDbgPreventUserNotifyL();
+		break;
+	case EASShdOpCodeDbgSnoozeAlarm:
+		completeMessage = CmdDbgSnoozeAlarmL();
+		break;
+	case EASShdOpCodeDbgSetEnvironmentChangesHandling:
+		completeMessage = CmdDbgSetEnvChgHandling();
+		break;	
+	//
+	// CMD - MISC
+	case EASShdOpCodeFetchTransferBuffer:
+		completeMessage = CmdFetchTransferBufferL();
+		break;
+	//
+	// CMD - FROM MASShdAlarmInfoProvider
+	case EASShdOpCodeAlarmCount:
+		completeMessage = CmdInfoAlarmCountL();
+		break;
+	case EASShdOpCodeAlarmAtIndex:
+		completeMessage = CmdInfoAlarmByIndexL();
+		break;
+	case EASShdOpCodeFlushServer:
+		completeMessage = ETrue;
+		break;
+ 
+
+	default:
+		ASSrvStaticUtils::PanicClient(Message(), EAlarmServerInitiatedClientPanicInvalidOperation);
+		break;
+		}
+		
+	return completeMessage;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmAddL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	// Read the client specified alarm object
+	TPckg<TASShdAlarm> package(iAlarmSink);
+	Message().ReadL(KSlot0, package);
+
+	if (iAlarmSink.IsFloating())
+		{
+		ConvertFromLocalToUtc(iAlarmSink);			
+		}
+	
+	//Add the Client SID to the AlarmData, only in the EKA2 platform
+	iAlarmSink.SetSid(Message().SecureId());
+	// Add the alarm
+	iSessionEngine->AlarmAddL(iAlarmSink);
+
+	// Get an up to date representation of the alarm (which 
+	// we will write back to the client's address space).
+	TASSrvAlarm* newAlarm = ServerData().Queue().QueueAlarmById(iAlarmSink.Id());
+	AlarmDataAttachL(*newAlarm);
+	// Write back to the client's address space 
+	TASSrvAlarm copyAlarm(*newAlarm);
+	
+	if (copyAlarm.IsFloating())
+		{
+		ConvertFromUtcToLocal(copyAlarm);
+		}
+		
+	TPckgC<TASShdAlarm> pNewAlarm(copyAlarm);
+	
+	Message().WriteL(KSlot0, pNewAlarm);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+void CASSrvSession::RequestExpiryNotificationL(TASSrvAlarm& aAlarm)
+	{
+	TRAPD(err, aAlarm.RequestExpiryNotificationL(Message()));
+	if	(err != KErrNone)
+		{
+		// Couldn't setup the notification, so cancel the alarm
+		ServerData().Queue().DeQueueAlarm(aAlarm);
+
+		// This will complete the request
+		User::Leave(err);
+		}
+	else	
+		{
+		//Clear sound pause flag if it is set in the case that there is a snoozed alarm is waiting. 
+		//This is to fix defect WAG-5B8H7J "Wrong behaviour if create an alarm before the snoozed alarm goes off."
+		ServerData().SoundSettings().ClearSoundPauseFlag();
+
+		TASSrvAlarm copyAlarm(aAlarm);
+		
+		if(copyAlarm.IsFloating())
+			{
+			ConvertFromUtcToLocal(copyAlarm);
+			}
+		
+		TPckgC<TASShdAlarm> pNewAlarm(copyAlarm);		
+		// Write back to the client's address space
+		Message().WriteL(KSlot0, pNewAlarm);
+
+		// Set the session id
+		aAlarm.SetOriginatingSessionId(iSessionEngine->MASSrvSessionId());
+		}
+	}
+
+
+TBool CASSrvSession::CmdAlarmAddWithNotificationL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	// Read and add the alarm, and updates iAlarmSink with the newly-allocated
+	// Alarm Id.
+	TAlarmId allocatedId = ServerData().Queue().NextFreeAlarmId();
+	TPckg<TASShdAlarm> package(iAlarmSink);
+	Message().ReadL(KSlot0, package);
+	
+	if (iAlarmSink.IsFloating())
+		{
+		ConvertFromLocalToUtc(iAlarmSink);			
+		}
+	
+	//Add the Client SID to the AlarmData, only in the EKA2 platform
+	iAlarmSink.SetSid(Message().SecureId());
+	//Add the Client SID to the AlarmData
+	iSessionEngine->AlarmAddL(iAlarmSink, allocatedId);
+	// Get a handle on the alarm
+	TASSrvAlarm* newAlarm = ServerData().Queue().QueueAlarmById(iAlarmSink.Id());
+	AlarmDataAttachL(*newAlarm);	
+	RequestExpiryNotificationL(*newAlarm);
+	// Don't complete the message - it's asynchronously completed when the alarm
+	// expires, or is cancelled.
+	return EFalse;
+	}
+
+void CASSrvSession::AlarmDataAttachL(TASSrvAlarm& aAlarm)
+	{
+	const TInt dataSizeInBytes = static_cast<TInt>(Message().Int1());
+	if(dataSizeInBytes>0)
+		{
+		HBufC8* data = HBufC8::NewLC(dataSizeInBytes);
+		TPtr8 pData(data->Des());
+		Message().ReadL(KSlot2, pData);
+		// Give ownership of the data to the alarm. This will leave with 
+		// KErrInUse should the specified alarm already have attached data.
+		CleanupStack::Pop(data);
+		aAlarm.DataAttachL(data);
+		}
+	}
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmNotificationCancelAndDeQueueL()
+	{
+	// want write access to alarm data
+	TRAPD(err, ServerData().Queue().CheckAlarmQueueWritableL());
+	if (err != KErrNone && err != KErrLocked)
+		{
+		User::Leave(err);	
+		}
+ 
+
+	// Get the alarm id from the client
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	// Get the alarm from the queue
+	TASSrvAlarm* alarm = ServerData().Queue().QueueAlarmById(alarmId);
+	if (alarm)
+		{
+		if(err == KErrNone)
+			{
+			alarm->RequestExpiryNotificationComplete(KErrCancel);
+			// Dequeue the alarm
+			alarm->DeQueue();	
+			}
+		else
+			{
+			alarm->RequestExpiryNotificationComplete(KErrLocked);	
+			}
+		}
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmDetailsL()
+	{
+	// Get the alarm id from the client
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+
+	// Populate the alarm sink with the details
+	iSessionEngine->AlarmDetailsL(alarmId, iAlarmSink);
+
+	if (iAlarmSink.IsFloating())
+		{
+		ConvertFromUtcToLocal(iAlarmSink);			
+		}
+
+	// Write back the alarm to the client's address space
+	
+	TPckgC<TASShdAlarm> package(iAlarmSink);	
+	
+	Message().WriteL(KSlot1, package);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDeleteL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	iSessionEngine->AlarmDeleteL(alarmId);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmCategoryL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	TPckgBuf<TAlarmCategory> category(iSessionEngine->AlarmCategoryL(alarmId));
+	Message().WriteL(KSlot1, category);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmOwnerL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	//
+	TFullName owner;
+	const TInt error = ServerData().SessionCollection().MASSessionCollectionAlarmOwner(alarmId, owner);
+	User::LeaveIfError(error);
+	//
+	Message().WriteL(KSlot1, owner);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmStatusL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	const TAlarmStatus status = static_cast<TAlarmStatus>(Message().Int1());
+	iSessionEngine->SetAlarmStatusL(alarmId, status);
+	//
+	return ETrue;
+	}
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmStatusForCalendarFileL()
+    {
+    // want write access to alarm data
+    ServerData().Queue().CheckAlarmQueueWritableL();
+    
+    HBufC* filename(HBufC::NewLC(Message().GetDesLengthL(KSlot0)));
+    TPtr fileNamePtr(filename->Des());
+    Message().ReadL(KSlot0, fileNamePtr);
+    
+    const TAlarmStatus status = static_cast<TAlarmStatus>(Message().Int1());
+    iSessionEngine->SetAlarmStatusForCalendarFileL(*filename, status);
+        
+    CleanupStack::PopAndDestroy(filename);
+    
+    return ETrue;
+    }
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmStatusL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	TPckgBuf<TAlarmStatus> status(iSessionEngine->AlarmStatusL(alarmId));
+	Message().WriteL(KSlot1, status);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmDayOrTimedL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	const TAlarmDayOrTimed dayOrTimed = static_cast<TAlarmDayOrTimed>(Message().Int1());
+	iSessionEngine->SetAlarmDayOrTimedL(alarmId, dayOrTimed);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmDayOrTimedL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	TPckgBuf<TAlarmDayOrTimed> dayOrTimed(iSessionEngine->AlarmDayOrTimedL(alarmId));
+	Message().WriteL(KSlot1, dayOrTimed);
+	//
+	return ETrue;
+	}
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmCharacteristicsL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	TPckgBuf<TAlarmCharacteristicsFlags> flags(iSessionEngine->AlarmCharacteristicsL(alarmId));
+	Message().WriteL(KSlot1, flags);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmCharacteristicsL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	//
+	TAlarmCharacteristicsFlags flags;
+	TPckg<TAlarmCharacteristicsFlags> pFlags(flags);
+	Message().ReadL(KSlot1, pFlags);
+	//
+	iSessionEngine->SetAlarmCharacteristicsL(alarmId, flags);
+	//
+	return ETrue;
+	}
+
+#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
+TBool CASSrvSession::CmdSetWakeupL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	const TBool enable = static_cast<TBool>(Message().Int1());
+	iSessionEngine->SetWakeupL(alarmId, enable);
+	//
+	return ETrue;
+	}
+#endif
+
+#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS
+TBool CASSrvSession::CmdGetAlarmDaysL()
+	{
+	const TAlarmId KAlarmId = static_cast<TAlarmId>(Message().Int0());
+	TPckgBuf<TUint8> alarmDays = iSessionEngine->AlarmDaysL(KAlarmId);
+	Message().WriteL(KSlot1, alarmDays);
+
+	return ETrue;
+	}
+
+TBool CASSrvSession::CmdSetAlarmDaysL()
+	{
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId KAlarmId = static_cast<TAlarmId>(Message().Int0());
+	const TUint8 KAlarmDays = static_cast<TUint8>(Message().Int1());
+	iSessionEngine->SetAlarmDaysL(KAlarmId, KAlarmDays);
+
+	return ETrue;
+	}
+
+TBool CASSrvSession::CmdSetContinuousL()
+	{
+	ServerData().Queue().CheckAlarmQueueWritableL();
+	
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	const TBool enable = static_cast<TBool>(Message().Int1());
+	iSessionEngine->SetContinuousL(alarmId, enable);
+	
+	return ETrue;
+	}
+
+TBool CASSrvSession::CmdContinuousL()
+	{
+	const TAlarmId KAlarmId = static_cast<TAlarmId>(Message().Int0());
+	TPckgBuf<TBool> continuous = iSessionEngine->ContinuousL(KAlarmId);
+	Message().WriteL(KSlot1, continuous);
+	
+	return ETrue;
+	}
+#endif
+
+TBool CASSrvSession::CmdOrphanAlarmL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	iSessionEngine->SetAlarmOrphanedL(alarmId);
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetClientDataL()
+	{
+	TPckg<TASShdAlarm> package(iAlarmSink);
+	Message().ReadL(KSlot1, package);
+
+  	TASSrvAlarm& alarm = ServerData().Queue().QueueAlarmByIdL(iAlarmSink.Id());
+  	alarm.ClientData1() = iAlarmSink.ClientData1();
+  	alarm.ClientData2() = iAlarmSink.ClientData2();
+  	TBitFlags16 tempFlags = alarm.ClientFlags();
+  	tempFlags.SetValue(iAlarmSink.ClientFlags().Value());
+  	alarm.ClientFlags() = tempFlags;
+	
+	return ETrue;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDataAttachL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	const TInt dataSizeInBytes = static_cast<TInt>(Message().Int1());
+	//
+	HBufC8* data = HBufC8::NewLC(dataSizeInBytes);
+	TPtr8 pData(data->Des());
+	Message().ReadL(KSlot2, pData);
+	
+	// Give ownership of the data to the alarm. This will leave with 
+	// KErrInUse should the specified alarm already have attached data.
+	// Or KErrLocked if Alarm Server Backup or Restore are in progress.
+	CleanupStack::Pop(data);
+	iSessionEngine->AlarmDataAttachL(alarmId, data);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDataDetachL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	//
+	// Remove the data from the pool - if the specified alarm doesn't exist
+	// within the data pool, then this will leave with KErrNotFound.
+	// Or KErrLocked if Alarm Server Backup or Restore are in progress.
+	iSessionEngine->AlarmDataDetachL(alarmId);	
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDataSizeL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	//
+	TASSrvAlarm& alarm = ServerData().Queue().QueueAlarmByIdL(alarmId);
+	Message().Complete(alarm.DataSizeL());
+	
+	// Already completed above
+	return EFalse;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmDataL()
+	{
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	//
+	TASSrvAlarm& alarm = ServerData().Queue().QueueAlarmByIdL(alarmId);
+	const TPtrC8 pData(alarm.DataL());
+	//
+	const TInt maxLength = static_cast<TInt>(Message().Int1());
+	if	(pData.Size() > maxLength)
+		{
+		ASSrvStaticUtils::PanicClient(Message(), EAlarmServerInitiatedClientPanicInsufficientRoomForAlarmData);
+		return EFalse;
+		}
+	
+	Message().WriteL(KSlot2, pData);
+	//
+	return ETrue;
+	}
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmStatusByCategoryL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmCategory category = { static_cast<TInt>(Message().Int0()) };
+	const TAlarmStatus status = static_cast<TAlarmStatus>(Message().Int1());
+	//
+	iSessionEngine->SetAlarmStatusByCategoryL(category, status);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmCountForCategoryL()
+	{
+	const TAlarmCategory category = { static_cast<TInt>(Message().Int0()) };
+	const TInt countForCategory = iSessionEngine->AlarmCountByCategory(category);
+	//
+	TPckg<TInt> pCount(countForCategory);
+	Message().WriteL(KSlot1, pCount);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDeleteAllByCategoryL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmCategory category = { static_cast<TInt>(Message().Int0()) };
+	const TBool restrictToOrphanedAlarms = static_cast<TBool>(Message().Int1());
+	iSessionEngine->DeleteAllAlarmsByCategoryL(category, restrictToOrphanedAlarms);
+	//
+	return ETrue;
+	}
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDeleteByCalendarFileL()
+    {
+    // want write access to alarm data
+    ServerData().Queue().CheckAlarmQueueWritableL();
+    
+    HBufC* filename(HBufC::NewLC(Message().GetDesLengthL(KSlot0)));
+    TPtr fileNamePtr(filename->Des());
+    Message().ReadL(KSlot0, fileNamePtr);
+
+    const TDeleteType whatToDelete = static_cast<TInt>(Message().Int1());
+    iSessionEngine->DeleteAllAlarmsByCalendarFileL(*filename, whatToDelete);
+    
+    CleanupStack::PopAndDestroy(filename);
+
+    return ETrue;
+    }
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmDeleteByCategoryL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	const TAlarmCategory category = { static_cast<TInt>(Message().Int0()) };
+	const TDeleteType whatToDelete = static_cast<TInt>(Message().Int1());
+	iSessionEngine->DeleteAllAlarmsByCategoryL(category, EFalse, whatToDelete);
+	//
+	return ETrue;
+	}
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAvailableCategoryListL()
+	{
+	// Get a list of available categories
+	RArray<TAlarmCategory>* list = iSessionEngine->AlarmCategoryListLC();
+
+	// Stream them out to a buffer
+	const TInt count = list->Count();
+	TransferBuffer().Reset();
+	RBufWriteStream stream(TransferBuffer());
+	CleanupClosePushL(stream); // don't think this is needed but adding it just to be sure
+	
+	// Externalize the count, since this is needed client-side
+	stream.WriteInt32L(count);
+	
+	// Now externalize the alarm categories, one by one.
+	for(TInt i=0; i<count; i++)
+		{
+		stream << (*list)[i];
+		}
+	stream.CommitL();
+	CleanupStack::Pop(&stream);
+
+	// Finished with the list now
+	CleanupStack::PopAndDestroy(list);
+
+	// Write the size of the list back to the client
+	TPckgBuf<TInt> size(TransferBuffer().Size());
+	Message().WriteL(KSlot0, size);
+
+	// Client will now fetch the contents of the transfer buffer in
+	// another request.
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmIdListForCategoryL()
+	{
+	// Get a list of available categories
+	const TAlarmCategory category = { static_cast<TInt>(Message().Int0()) };
+	RArray<TAlarmId>* list = iSessionEngine->AlarmIdListByCategoryLC(category);
+
+	// Stream to transfer buffer
+	StreamAlarmIdsToTransferBufferL(*list);
+	CleanupStack::PopAndDestroy(list);
+
+	// Client will now fetch the contents of the transfer buffer in
+	// another request.
+	// coverity [leaked_storage]
+	return ETrue;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdAlarmCountByStateL()
+	{
+	const TAlarmState state = static_cast<TAlarmState>(Message().Int0());
+	const TInt count = iSessionEngine->AlarmCountByState(state);
+	//
+	TPckg<TInt> pCount(count);
+	Message().WriteL(KSlot1, pCount);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmIdListByStateL()
+	{
+	// Get a list of available categories
+	const TAlarmState state = static_cast<TAlarmState>(Message().Int0());
+	RArray<TAlarmId>* list = iSessionEngine->AlarmIdListByStateLC(state);
+
+	// Stream to transfer buffer
+	StreamAlarmIdsToTransferBufferL(*list);
+	CleanupStack::PopAndDestroy(list);
+
+	// Client will now fetch the contents of the transfer buffer in
+	// another request.
+	// coverity [leaked_storage]
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmIdListL()
+	{
+	// Get a list of available categories
+	RArray<TAlarmId>* list = iSessionEngine->AlarmIdListLC();
+
+	// Stream to transfer buffer
+	StreamAlarmIdsToTransferBufferL(*list);
+	CleanupStack::PopAndDestroy(list);
+
+	// Client will now fetch the contents of the transfer buffer in
+	// another request.
+	// coverity [leaked_storage]
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetNextDueAlarmIdL()
+	{
+	// Fetch the head item from the queue. If there isn't one, then we return KNullAlarmID
+	const TAlarmId id = ServerData().Timer().NextDueAlarmId();
+	TPckgC<TAlarmId> nextDueAlarm(id);
+	Message().WriteL(KSlot0, nextDueAlarm);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdNumberOfActiveAlarmsInQueueL()
+	{
+	const TInt count = iSessionEngine->NumberOfActiveAlarmsInQueue();
+	TPckgC<TInt> pCount(count);
+	Message().WriteL(KSlot0, pCount);
+	//
+	return ETrue;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmSoundStateL()
+	{
+	const TAlarmGlobalSoundState state = static_cast<TAlarmGlobalSoundState>(Message().Int0());
+	ServerData().SoundSettings().SetGlobalSoundState(state);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmSoundStateL()
+	{
+	TPckgBuf<TAlarmGlobalSoundState> soundState(ServerData().SoundSettings().GlobalSoundState());
+	Message().WriteL(KSlot0, soundState);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmSoundsSilentUntilL()
+	{
+	TTime time;
+	TPckg<TTime> pTime(time);
+	Message().ReadL(KSlot0, pTime);
+	//
+	
+	time -= User::UTCOffset(); // Value is in local time format
+	TDateTime t = time.DateTime();
+	ASSrvStaticUtils::RoundTimeDownToTheMinute(time);
+	t = time.DateTime();
+	
+	// Can't defer time until a point in the past
+	TTime now(ASSrvStaticUtils::UtcTimeNow());
+	if	(time < now)
+		{
+		User::Leave(KErrArgument);
+		}
+	else
+		{
+		ServerData().SoundController().SetFloating();
+		ServerData().SoundController().MakeAllSoundsQuietUntil(time);
+	//
+		}
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmSoundsSilentForL()
+	{
+	TTimeIntervalMinutes timeIntervalMinutes;
+	TPckg<TTimeIntervalMinutes> pTimeIntervalMinutes(timeIntervalMinutes);
+	Message().ReadL(KSlot0, pTimeIntervalMinutes);
+
+	// Can't defer time until a point in the past
+	TTime now(ASSrvStaticUtils::UtcTimeNow());	
+	TTime time(now);
+		
+	time += timeIntervalMinutes;
+	
+	if	(time < now)
+		{
+		User::Leave(KErrArgument);
+		}
+	else
+		{
+		ServerData().SoundController().SetFixed();
+		ServerData().SoundController().MakeAllSoundsQuietUntil(time);
+		}
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmSoundsSilentUntilL()
+	{
+	if	(ServerData().SoundController().InQuietPeriod())
+		{
+		// Return as local time
+		TPckgBuf<TTime> time(ServerData().SoundController().SoundsQuietUntil() + User::UTCOffset());
+		Message().WriteL(KSlot0, time);
+		}
+	else
+		{
+		// Not in a silent period
+		User::Leave(KErrGeneral);
+		}
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdCancelAlarmSilenceL()
+	{
+	CASSrvSoundController& soundController = ServerData().SoundController();
+	soundController.CancelSilence();
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmSoundsTemporarilySilencedL()
+	{
+	CASSrvSoundController& soundController = ServerData().SoundController();
+	const TBool inQuietPeriod = soundController.InQuietPeriod();
+	TPckgC<TBool> package(inQuietPeriod);
+	Message().WriteL(KSlot0, package);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdSetAlarmPlayIntervalsL()
+	{
+	// want write access to alarm data
+	ServerData().Queue().CheckAlarmQueueWritableL();
+
+	// Make the transfer buffer big enough to hold the serialized 
+	// play intervals. Int1 holds the size in bytes of the buffer required.
+	TransferBuffer().Reset();
+	//
+	const TInt transferBufferSizeRequired = Message().Int1();
+	TransferBuffer().ResizeL(transferBufferSizeRequired);
+
+	// Now read the buffer
+	TPtr8 pBuffer(TransferBuffer().Ptr(0));
+	Message().ReadL(KSlot0, pBuffer);
+
+	// Create stream view on buffer
+	RBufReadStream stream(TransferBuffer());
+	CleanupClosePushL(stream);
+
+	// Now internalize the play interval
+	RArray<TASSrvAlarmSoundDetails>* newIntervals = ASSrvStaticUtils::InternalizeSoundPlayIntervalsLC(stream);
+	
+	// Check the sound play intervals are valid
+	const TInt error = ASSrvStaticUtils::ValidateSoundPlayIntervals(*newIntervals);
+	User::LeaveIfError(error);
+
+	// They're okay, so update the sound settings
+	const TInt setError = ServerData().SoundSettings().SetSoundIntervals(newIntervals);
+	User::LeaveIfError(setError);
+
+	CleanupStack::Pop(newIntervals);
+	CleanupStack::PopAndDestroy(&stream);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdGetAlarmPlayIntervalsL()
+	{
+	// Externalize all the sound play intervals to the transfer buffer.
+	TransferBuffer().Reset();
+	RBufWriteStream stream(TransferBuffer());
+	CleanupClosePushL(stream);
+	ServerData().SoundSettings().ExternalizeSoundIntervalsL(stream);
+	stream.CommitL();
+	CleanupStack::PopAndDestroy(&stream);
+
+	// Write the size of the list back to the client
+	TPckgBuf<TInt> size(TransferBuffer().Size());
+	Message().WriteL(KSlot0, size);
+	//
+	return ETrue;
+	}
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdNotifyChangeL()
+	{
+	if	(iFlags.IsSet(EAlarmSessionFlagsNotifyPending))
+		{
+		ASSrvStaticUtils::PanicClient(Message(), EAlarmServerInitiatedClientPanicChangeNotificationAlreadyOutstanding);
+		return EFalse;
+		}
+
+	// If we have something in the buffer, notify the client straight away
+	if	(iChangeEventBuffer.Count())
+		{
+		// Oldest event is at the head of the queue
+		const TASSrvBufferredEvent& event = iChangeEventBuffer[0];
+
+		// BC: Modification to maintain BC with older version of alarm server
+		// the new alarm server must not write to the client because there is nothing in the 
+		// client address space to write to
+		if(Message().Int1() == EFalse)
+			{
+			TPckgC<TAlarmId> package(event.AlarmId());
+			Message().WriteL(KSlot0, package);
+			}
+		Message().Complete(event.Code());
+		iChangeEventBuffer.Remove(0);
+		}
+	else
+		{
+		// Wait for something
+		iFlags.Set(EAlarmSessionFlagsNotifyPending);
+		iAlarmQueueChangeNotificationMessage = Message();
+		}
+	//
+	return EFalse;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdNotifyChangeCancelL()
+	{
+	// Can't panic the client if there isn't a pending request,
+	// because its possible for the client thread to request
+	// cancellation (when it still has an outstanding request)
+	// but the alarm server thread runs because an event occurs,
+	// hence the scheduler doesn't return to idle (to service
+	// the cancellation request) until after an event has just
+	// been completed. The TT_AMOD test code from TimeW exhibits
+	// this problem.
+	if	(iFlags.IsSet(EAlarmSessionFlagsNotifyPending))
+		CompleteChangeNotificationMessage(KErrCancel, KNullAlarmId);
+	return ETrue;
+	}
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdDbgShutDownServerL()
+	{
+#ifdef _DEBUG
+	CActiveScheduler::Stop();
+#endif
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdDbgFailAllocL()
+	{
+#ifdef _DEBUG
+	const TInt count = Message().Int0();
+	if	(count)
+		{
+		__UHEAP_FAILNEXT(count);
+		}
+	else
+		__UHEAP_RESET;
+#endif
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdDbgPreventUserNotifyL()
+	{
+#ifdef _DEBUG
+	const TBool preventUserNotifications = static_cast<TBool>(Message().Int0());
+	ServerData().NotificationCoordinator().__DbgPreventUserNotify(preventUserNotifications);
+#endif
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdDbgSnoozeAlarmL()
+	{
+#ifdef _DEBUG
+	const TAlarmId alarmId = static_cast<TAlarmId>(Message().Int0());
+	//
+	TTime timeWhenAlarmShouldAwaken;
+	TPckg<TTime> package(timeWhenAlarmShouldAwaken);
+	Message().ReadL(KSlot1, package);
+	//
+
+	TASSrvAlarm& alarm = ServerData().Queue().QueueAlarmByIdL(alarmId);
+	alarm.Snooze(timeWhenAlarmShouldAwaken);
+#endif
+	return ETrue;
+	}
+//*************************************************************************************
+
+TBool CASSrvSession::CmdDbgSetEnvChgHandling()
+	{
+#ifdef _DEBUG
+	TInt val = Message().Int0();
+	ServerData().EnvironmentChangeManager().SetEnvironmentChangesHandling(val);
+#endif
+	return ETrue;
+	}
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdInfoAlarmCountL()
+	{
+	TPckg<TInt> pCount(ServerData().Queue().QueueAlarmCount());
+	Message().WriteL(KSlot0, pCount);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdInfoAlarmByIndexL()
+	{
+	CASSrvAlarmQueue& queue = ServerData().Queue();
+
+	// Get the alarm index from the client
+	const TInt count = queue.QueueAlarmCount();
+	const TInt index = Message().Int0();
+	if	(index < count)
+		{
+		// Populate the alarm sink with the details
+		const TASShdAlarm& alarm = queue.QueueAlarmAt(index);
+
+		// Write back the alarm to the client's address space
+		TPckgC<TASShdAlarm> package(alarm);
+		Message().WriteL(KSlot1, package);
+		}
+	else
+		User::Leave(KErrNotFound);
+	//
+	return ETrue;
+	}
+
+
+//
+//
+//
+
+
+//*************************************************************************************
+TBool CASSrvSession::CmdFetchTransferBufferL()
+	{
+	TPtr8 pBuffer(iTransferBuffer->Ptr(0));
+	Message().WriteL(KSlot0, pBuffer);
+	//
+	return ETrue;
+	}
+
+
+//*************************************************************************************
+/**
+ * Externalize the specified array to the transfer buffer
+ */
+void CASSrvSession::StreamAlarmIdsToTransferBufferL(RArray<TAlarmId>& aArray)
+	{
+	// Stream them out to a buffer
+	const TInt count = aArray.Count();
+	TransferBuffer().Reset();
+	RBufWriteStream stream(TransferBuffer());
+	CleanupClosePushL(stream); // don't think this is needed but adding it just to be sure
+	
+	// Externalize the count, since this is needed client-side
+	stream.WriteInt32L(count);
+	
+	// Now externalize the alarm categories, one by one.
+	for(TInt i=0; i<count; i++)
+		{
+		stream.WriteInt32L(aArray[i]);
+		}
+	stream.CommitL();
+	CleanupStack::Pop(&stream);
+
+	// Write the size of the list back to the client
+	TPckgBuf<TInt> size(TransferBuffer().Size());
+	Message().WriteL(KSlot1, size);
+	}
+
+
+//*************************************************************************************
+/**
+ * If there isn't memory to buffer an event then we just overwrite the 
+ * head event.
+ */
+void CASSrvSession::CompleteChangeNotificationMessage(TInt aCompletionCode, TAlarmId aAlarmId)
+	{
+	// If the client hasn't set up a pending request then we buffer the event.
+	// Events are always added to the end of the buffer. The oldest event is
+	// at the head.
+	if	(!iFlags.IsSet(EAlarmSessionFlagsNotifyPending))
+		{
+		// Add event to buffer, replacing the oldest if the buffer is full.
+		TInt count = iChangeEventBuffer.Count();
+		if	(count == KAlarmServerMaxNumberOfChangeEventsToBuffer)
+			{
+			// Delete the oldest event
+			--count;
+			iChangeEventBuffer.Remove(0);
+			}
+
+		// Try and insert. If there isn't memory to buffer the event then
+		// we replace the most recent event with this new one.
+		const TInt error = iChangeEventBuffer.Append(TASSrvBufferredEvent(aCompletionCode, aAlarmId));
+		if	(error != KErrNone && count)
+			{
+			TASSrvBufferredEvent& event = iChangeEventBuffer[count - 1];
+			event = TASSrvBufferredEvent(aCompletionCode, aAlarmId);
+			}
+		}
+	else
+		{
+		// Report event straight away
+		iFlags.Clear(EAlarmSessionFlagsNotifyPending);
+
+		// BC: Modification to enable BC with old alarm server; 
+		// this is so that the server does not write to the client address space;
+		// the old API does not include a member variable that the new alarm server
+		// assumes in the client and so it is important that the server does not write
+		// to this address in the old client.
+		if(iAlarmQueueChangeNotificationMessage.Int1() != EFalse)
+			{
+			iAlarmQueueChangeNotificationMessage.Complete(aCompletionCode);
+			}
+		else
+			{
+			// Write to client's address space
+			TPckgC<TAlarmId> package(aAlarmId);
+			TRAPD(error, iAlarmQueueChangeNotificationMessage.WriteL(0, package));
+			if	(error != KErrNone && error == KErrBadDescriptor)
+				ASSrvStaticUtils::PanicClient(iAlarmQueueChangeNotificationMessage, EAlarmServerInitiatedClientPanicBadDescriptor);
+			else
+				iAlarmQueueChangeNotificationMessage.Complete(aCompletionCode);
+			}
+		}
+	}
+
+/**
+Converts a UTC alarm to local alarm
+*/
+void CASSrvSession::ConvertFromUtcToLocal(TASShdAlarm& aAlarm) const
+    {
+	// converting from UTC to local.
+    TTimeIntervalSeconds cachedoffset = ServerData().CachedUtcOffset();
+
+	if (aAlarm.NextDueTime() != Time::NullTTime())
+	    {
+	    aAlarm.NextDueTime() += cachedoffset;
+	    }
+	if (aAlarm.OriginalExpiryTime() != Time::NullTTime())
+	    {
+	    aAlarm.OriginalExpiryTime() += cachedoffset;
+	    } 
+	}
+
+/**
+Converts a local alarm to UTC alarm
+*/
+void CASSrvSession::ConvertFromLocalToUtc(TASShdAlarm& aAlarm) const
+    {
+	// converting times from local to UTC.
+    TTimeIntervalSeconds cachedoffset = ServerData().CachedUtcOffset();
+
+	if (aAlarm.NextDueTime() != Time::NullTTime())
+	    {
+	    aAlarm.NextDueTime() -= cachedoffset;
+	    }	
+	if (aAlarm.OriginalExpiryTime() != Time::NullTTime())
+	    {
+	    aAlarm.OriginalExpiryTime() -= cachedoffset;
+	    }
+	}
+