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

		{