// 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 "ASSrvSessionEngine.h"

// System includes

// User includes

#include "ASSrvAlarmStore.h"

#include "ASSrvAlarmQueue.h"

#include "ASSrvStaticUtils.h"

#include "ASSrvServerWideData.h"

#include "ASSrvAnyEventManager.h"

#include "ASSrvIteratorByState.h"

#include "ASSrvIteratorByStatus.h"

#include "ASSrvSessionCollection.h"

#include "ASSrvIteratorByCategory.h"

#include "ASSrvIteratorBySessionId.h"

// Type definitions

// Constants

const TAlarmCategory KCalendarCategeory = {0x101F4A70};

// Enumerations

// Classes referenced

//

// ----> CASSrvSessionEngine (source)

//

//*************************************************************************************

CASSrvSessionEngine::CASSrvSessionEngine(CASSrvServerWideData& aServerWideData, MASSrvAnyEventObserver& aChangeObserver, MASSrvSession& aSession)

:	iServerWideData(aServerWideData), iChangeObserver(aChangeObserver), iSession(aSession)

	{

	}

//*************************************************************************************

CASSrvSessionEngine::~CASSrvSessionEngine()

	{

	ServerData().SessionCollection().MASSessionCollectionDetach(*this);

	ServerData().AnyEventManager().MASAnyEventManagerObserverRemove(*this);

	}

//*************************************************************************************

void CASSrvSessionEngine::ConstructL()

	{

	ServerData().AnyEventManager().MASAnyEventManagerObserverAddL(*this);

	iSessionId = ServerData().SessionCollection().MASSessionCollectionAttachL(*this);

	}

//*************************************************************************************

CASSrvSessionEngine* CASSrvSessionEngine::NewL(CASSrvServerWideData& aServerWideData, MASSrvAnyEventObserver& aChangeObserver, MASSrvSession& aSession)

	{

	CASSrvSessionEngine* self = new(ELeave) CASSrvSessionEngine(aServerWideData, aChangeObserver, aSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

//

//

//

//*************************************************************************************

/**

 * @see MASSrvAnyEventObserver

 *

 * Facade interface that notifies observer about event. No real processing done

 * by this object.

 */

void CASSrvSessionEngine::MASSrvAnyEventHandleChange(TAlarmChangeEvent aEvent, TAlarmId aAlarmId)

	{

	iChangeObserver.MASSrvAnyEventHandleChange(aEvent, aAlarmId);

	}

//

//

//

//*************************************************************************************

/**

 * @see MASSrvSession

 *

 * Facade to the real session

 */

TASSrvSessionId CASSrvSessionEngine::MASSrvSessionId() const

	{

	return iSessionId;

	}

//*************************************************************************************

/**

 * @see MASSrvSession

 *

 * Facade to the real session

 */

void CASSrvSessionEngine::MASSrvSessionFullName(TDes& aDes) const

	{

	iSession.MASSrvSessionFullName(aDes);

	}

//

//

//

//*************************************************************************************

/**

 * Add an alarm to the alarm server

 */

void CASSrvSessionEngine::AlarmAddL(TASSrvAlarm& aAlarm, TAlarmId aSpecificAlarmId)

	{

	// Must clear this - all alarms will have their Id's allocated later

	aAlarm.Id() = KNullAlarmId;	

	// clear associateddata, session and state flags

	aAlarm.ClearFlags();

	// Check the alarm

	const TInt error = ASSrvStaticUtils::ValidateAlarm(aAlarm);

	User::LeaveIfError(error);

	// Assign session id

	aAlarm.SetOriginatingSessionId(MASSrvSessionId());

	// Reset alarm state

	aAlarm.SetState(EAlarmStateInPreparation);

	// Add the alarm to the queue. This will update the timer if this

	// new alarm is now the next alarm.

	ServerData().Queue().QueueAlarmAndAllocateIdL(aAlarm, aSpecificAlarmId);

	}

//*************************************************************************************

/**

 * Return information about an alarm

 */

void CASSrvSessionEngine::AlarmDetailsL(TAlarmId aAlarmId, TASSrvAlarm& aAlarm) const

	{

	// Fetch the alarm details if the specified alarm exists.

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, aAlarm));

	}

//*************************************************************************************

/**

 * Delete an alarm from the alarm server

 */

void CASSrvSessionEngine::AlarmDeleteL(TAlarmId aAlarmId)

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	// If the alarm has a notification request outstanding against

	// it, then we don't allow it to be deleted (the only way of

	// removing the alarm is by cancelling the session notification).

	if	(alarm.HasNotificationRequestPending())

		User::Leave(KErrAccessDenied);

	ServerData().Queue().DeQueueAlarm(alarm);

	}

//*************************************************************************************

/**

 * Return the category of a given alarm

 */

TAlarmCategory CASSrvSessionEngine::AlarmCategoryL(TAlarmId aAlarmId) const

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	return alarm.Category();

	}

//*************************************************************************************

/**

 * Set the status of an alarm

 */

void CASSrvSessionEngine::SetAlarmStatusL(TAlarmId aAlarmId, TAlarmStatus aStatus)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	User::LeaveIfError(alarm.SetStatus(aStatus));

	}

//*************************************************************************************

void CASSrvSessionEngine::SetAlarmStatusForCalendarFileL(const TDesC& aCalendarFileName, TAlarmStatus aStatus)

    {

    CASSrvAlarmQueue& queue = ServerData().Queue();

    RArray<TAlarmId>* calendarAlarmIds = AlarmIdListByCategoryLC(KCalendarCategeory);

    const TInt KCalendarAlarmCount(calendarAlarmIds->Count());

    for (TInt i(0) ; i < KCalendarAlarmCount ; ++i)

        {

        TASSrvAlarm* alarm = queue.QueueAlarmById((*calendarAlarmIds)[i]);

        const TAgnAlarmInfo* alarmInfo = reinterpret_cast<const TAgnAlarmInfo*>(alarm->DataL().Ptr());

        TBool correctFile = (alarmInfo->iFileName.CompareF(aCalendarFileName) == 0);

        if(correctFile)

            {

            alarm->SetStatus(aStatus);

            }

        }

     CleanupStack::PopAndDestroy(calendarAlarmIds);

     // coverity[leaked_storage]

    }

//*************************************************************************************

/**

 * Return the status of a given alarm

 */

TAlarmStatus CASSrvSessionEngine::AlarmStatusL(TAlarmId aAlarmId) const

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	return alarm.Status();

	}

//*************************************************************************************

/**

 * Set the day/timed status of an alarm

 */

void CASSrvSessionEngine::SetAlarmDayOrTimedL(TAlarmId aAlarmId, TAlarmDayOrTimed aDayOrTimed)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	alarm.DayOrTimed() = aDayOrTimed;

	}

//*************************************************************************************

/**

 * Return the day/timed status of a given alarm

 */

TAlarmDayOrTimed CASSrvSessionEngine::AlarmDayOrTimedL(TAlarmId aAlarmId) const

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	return alarm.DayOrTimed();

	}

//*************************************************************************************

/**

 * Set the characteristics of an alarm

 */

void CASSrvSessionEngine::SetAlarmCharacteristicsL(TAlarmId aAlarmId, TAlarmCharacteristicsFlags aCharacteristics)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	alarm.SetCharacteristicsL(aCharacteristics, MASSrvSessionId());

	}

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

void CASSrvSessionEngine::SetWakeupL(TAlarmId aAlarmId, TBool aEnable)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	alarm.SetWakeupAndNotifyQueueL(aEnable);

	}

#endif

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS

void CASSrvSessionEngine::SetAlarmDaysL(TAlarmId aAlarmId, TUint8 aAlarmDays)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	alarm.SetAlarmDaysL(aAlarmDays);

	}

TUint8 CASSrvSessionEngine::AlarmDaysL(TAlarmId aAlarmId) const

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	return alarm.AlarmDays();

	}

void CASSrvSessionEngine::SetContinuousL(TAlarmId aAlarmId, TBool aContinuous)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	alarm.SetContinuous(aContinuous);

	}

TBool CASSrvSessionEngine::ContinuousL(TAlarmId aAlarmId) const

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	return alarm.Continuous();

	}

#endif

void CASSrvSessionEngine::SetAlarmOrphanedL(TAlarmId aAlarmId)

	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	TASSrvAlarm& alarm = queue.QueueAlarmByIdL(aAlarmId);

	alarm.SetAlarmOrphaned();

	}

//*************************************************************************************

/**

 * Return the characteristics of an alarm

 */

TAlarmCharacteristicsFlags CASSrvSessionEngine::AlarmCharacteristicsL(TAlarmId aAlarmId) const

	{

	TASSrvAlarm alarm(ServerData());

	User::LeaveIfError(ServerData().Queue().QueueAlarmById(aAlarmId, alarm));

	return alarm.Characteristics();

	}

//

//

//

//*************************************************************************************

void CASSrvSessionEngine::AlarmDataAttachL(TAlarmId aAlarmId, HBufC8* aData)

	{

	// Give ownership of the data to the alarm. This will leave with 

	// KErrInUse should the specified alarm already have attached data.

	TASSrvAlarm& alarm = ServerData().Queue().QueueAlarmByIdL(aAlarmId);

	alarm.DataAttachL(aData);

	}

//*************************************************************************************

void CASSrvSessionEngine::AlarmDataDetachL(TAlarmId aAlarmId)

	{

	// Remove the data from the pool - if the specified alarm doesn't exist

	// within the data pool, then this will leave with KErrNotFound.

	TASSrvAlarm& alarm = ServerData().Queue().QueueAlarmByIdL(aAlarmId);

	alarm.DataDetachL();	

	}

//*************************************************************************************

/**

 * Change all alarms of a given category to have the specified status

 */

void CASSrvSessionEngine::SetAlarmStatusByCategoryL(TAlarmCategory aCategory, TAlarmStatus aStatus)

	{

	//

	CASSrvAlarmQueue& queue = ServerData().Queue();

	RASSrvIteratorByCategory iterator(queue, aCategory);

	iterator.Open();

	//

	while(iterator.NextAlarmAvailable())

		{

		TASSrvAlarm* alarm = queue.QueueAlarmById(iterator.NextAlarm().Id());

		User::LeaveIfError(alarm->SetStatus(aStatus));

		}

	}

//*************************************************************************************

/**

 * Return the number of alarms within the alarm server queue that

 * have the specified category identifier.

 */

TInt CASSrvSessionEngine::AlarmCountByCategory(TAlarmCategory aCategory) const

	{

	TInt count = 0;

	//

	RASSrvIteratorByCategory iterator(ServerData().Queue(), aCategory);

	iterator.Open();

	//

	while(iterator.NextAlarmAvailable())

		{

		iterator.NextAlarm();

		++count;

		}

	return count;

	}

//*************************************************************************************

/**

 * Return the number of alarms within the alarm server that 

 * have the specified state.

 */

TInt CASSrvSessionEngine::AlarmCountByState(TAlarmState aState) const

	{

	TInt count = 0;

	//

	RASSrvIteratorByState iterator(ServerData().Queue(), aState);

	iterator.Open();

	//

	while(iterator.NextAlarmAvailable())

		{

		iterator.NextAlarm();

		++count;

		}

	return count;

	}

//*************************************************************************************

/**

 * Delete all of the alarms within the alarm server queue which

 * match that of the specified category and alarm's state

 */

void CASSrvSessionEngine::DeleteAllAlarmsByCategoryL(TAlarmCategory aCategory, TBool aRestrictToOrphanedAlarms, TDeleteType aWhatToDelete)

 	{

	CASSrvAlarmQueue& queue = ServerData().Queue();

	RArray<TAlarmId>* alarmToDeleteIds = AlarmIdListByCategoryLC(aCategory);

	TInt count = alarmToDeleteIds->Count();

	//

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

		{

		const TASSrvAlarm* alarm = queue.QueueAlarmById((*alarmToDeleteIds)[i]);

		const TBool isOrphanedAndDeletable = aRestrictToOrphanedAlarms && alarm->HasBecomeOrphaned();

		TBool toDelete=EFalse;

		if (!aRestrictToOrphanedAlarms || isOrphanedAndDeletable)

			{

			if(!aWhatToDelete)

				toDelete=ETrue;

			else

				{

				switch (alarm->State())

					{

					case EAlarmStateInPreparation:

						{

						toDelete=ETrue;

						break;

						}

					case EAlarmStateQueued:

						{

						if (aWhatToDelete&EFuture)

							{

							toDelete=ETrue;

							}

						break;

						}

					case EAlarmStateNotified:

						{

						if (aWhatToDelete&EExpired)

							{

							toDelete=ETrue;

							}

						break;

						}

					case EAlarmStateSnoozed:

					case EAlarmStateWaitingToNotify:

					case EAlarmStateNotifying:

						{

						if (aWhatToDelete&EActive)

							{

							toDelete=ETrue;

							}

						break;

						}

					default:

						__ASSERT_DEBUG(EFalse, ASSrvStaticUtils::Fault(ASSrvStaticUtils::EASSrvFaultAlarmStateNotHandled));

					break;

					}

				}

			 if (toDelete)

				{

				queue.DeQueueAlarm(*alarm);

				}

			}

		}

	alarmToDeleteIds->Close();

	CleanupStack::PopAndDestroy(alarmToDeleteIds);

	// coverity [leaked_storage]

	}

//*************************************************************************************

/**

 * Delete all of the alarms within the alarm server queue which

 * match that of the specified calendar file name and alarm's state

 */

void CASSrvSessionEngine::DeleteAllAlarmsByCalendarFileL(const TDesC& aCalendarFileName, TDeleteType aWhatToDelete)

    {

    RDebug::Print(_L("CASSrvSessionEngine::DeleteAllAlarmsByCalendarFileL"));

    CASSrvAlarmQueue& queue = ServerData().Queue();

    RArray<TAlarmId>* calendarAlarmIds = AlarmIdListByCategoryLC(KCalendarCategeory);

    const TInt KCalendarAlarmCount(calendarAlarmIds->Count());

    for (TInt i(0) ; i < KCalendarAlarmCount ; ++i)

        {

        const TASSrvAlarm* alarm = queue.QueueAlarmById((*calendarAlarmIds)[i]);

        TBool correctDeleteType(ETrue);

        const TAgnAlarmInfo* alarmInfo = reinterpret_cast<const TAgnAlarmInfo*>(alarm->DataL().Ptr());

        TBool correctFile = (alarmInfo->iFileName.CompareF(aCalendarFileName) == 0);

        if (aWhatToDelete && correctFile)

            {

            switch (alarm->State())

                {

                case EAlarmStateInPreparation: