// 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: Implementation of the class representing the Alarm Queue 

//

#include <e32property.h>

#include "ASSrvAlarmQueue.h"

// User Includes

#include "ASSrvTimer.h"

#include "ASSrvStaticUtils.h"

#include "ASSrvServerWideData.h"

#include "ASSrvAnyEventManager.h"

#include "ASSrvIteratorByState.h"

#include "ASSrvIteratorByStatus.h"

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS

#include "ASSrvIteratorByCategory.h"

#endif

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

#include "ASSrvIteratorByWakeup.h"

#endif

#include "ASSrvEnvironmentChangeManager.h"

#include "ASSrvSoundSettings.h"

#include "ASSrvDataPool.h"

#include "ASSrvDSTChange.h"

// Constants

const TInt KASSrvNumberOfDaysInOneWeek = 7;

// Macro for security policy objects

static _LIT_SECURITY_POLICY_PASS(KReadPolicy);

static _LIT_SECURITY_POLICY_S0(KWritePolicy, 0x101f5027);

// Enumerations

#define DEBUG_PRINT_QUEUE(a){   RDebug::Print(_L(a));                  \

                                 for(TInt i=0; i<iAlarms.Count(); i++)  \

                                     {                                  \

                                     const TASSrvAlarm& alarm = QueueAlarmAt(i); \

                                     RDebug::Print(_L("ALARMSERVER\t Alarm[%02d] \"%S\" (%d)"), i, &alarm.Message(), alarm.Id()); \

                                     }                              \

                                RDebug::Print(_L("\n"));            \

                            }

// Uncomment the following define macro for getting logs in verbose mode

// #define VERBOSE_DEBUG

#if defined(VERBOSE_DEBUG)

#define DEBUG_PRINT1(A)			RDebug::Print(A)

#define DEBUG_PRINT2(A,B)		RDebug::Print(A,B)

#else

#define DEBUG_PRINT1(A)

#define DEBUG_PRINT2(A,B)

#endif

CASSrvAlarmQueue::CASSrvAlarmQueue(CASSrvServerWideData& aServerWideData)

    :iServerWideData(aServerWideData)

	{

	}

CASSrvAlarmQueue::~CASSrvAlarmQueue()

	{

	ServerData().EnvironmentChangeManager().RequestEnvironmentChangesCancel(*this);

	iAlarmObservers.Close();

 	iAlarms.ResetAndDestroy();

 	iAlarms.Close();

	if (iInternalizeAlarmQueue.Count() != 0)

	    {

	    iInternalizeAlarmQueue.ResetAndDestroy();

	    }

	iInternalizeAlarmQueue.Close();

 	iNotificationList.Close();

 	delete iASSrvDSTChange;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

 	iSsmRtcAdaptation.Close();

#endif

	}

void CASSrvAlarmQueue::ConstructL()

	{

	ServerData().EnvironmentChangeManager().RequestEnvironmentChangesL(*this);

	iPreviousUtcOffset = User::UTCOffset();

	iASSrvDSTChange = CASSrvDSTChange::NewL(*this);

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	iSsmRtcAdaptation.Connect();

	// Notify the listeners of 'KWakeupAlarmPubSubKey' key that the alarm queue is yet  to be internalized 

	// by Alarm Server on its start-up at the device boot time.

	RProperty::Define(KAlarmServerPubSubCategory, KWakeupAlarmPubSubKey, RProperty::EInt, KReadPolicy, KWritePolicy);

	RProperty::Set( KAlarmServerPubSubCategory, KWakeupAlarmPubSubKey, EActiveWakeupAlarmUninitialized );

	DEBUG_PRINT1(_L("Set the KWakeupAlarmPubSubKey to EActiveWakeupAlarmUninitialized (startup)"));

#endif

	}

CASSrvAlarmQueue* CASSrvAlarmQueue::NewL(CASSrvServerWideData& aServerWideData)

	{

	CASSrvAlarmQueue* self = new(ELeave) CASSrvAlarmQueue(aServerWideData);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * @see MASSrvEnvironmentChangeObserver

 */

void CASSrvAlarmQueue::MEnvChangeHandleEvent(TInt aChanges, TUint aWorkdays, TBool aWorkdaysChanged)

	{

	// Locale changes can be triggered by a lot of reasons, process locale

	// changes only due to utc offset change and workdays change.

	if ( (aChanges & EChangesSystemTime) || aWorkdaysChanged || (aChanges & EChangesLocale && (iPreviousUtcOffset != User::UTCOffset())) )

		{

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS

		TBool possibleHiddenFloatingAlarm(EFalse);

		// Store the time of the first calendar alarm, as it may have been skipped		

		TTime firstSkippedAlarmLocalTime(0);

		const TAlarmId headCalendarAlarmId = HeadCalendarAlarmId();

		if (headCalendarAlarmId != KNullAlarmId)

			{

			const TASSrvAlarm* headCalendarAlarm = QueueAlarmById(headCalendarAlarmId);

			firstSkippedAlarmLocalTime = headCalendarAlarm->NextDueTime();

			// The calendar server adds a single alarm at a time.  If this 

			// alarm is fixed, a skipped alarm instances notification must be 

			// sent, since the calendar server may have had other unqueued 

			// alarms that were skipped.

			possibleHiddenFloatingAlarm = !headCalendarAlarm->IsFloating() && (headCalendarAlarm->NextDueTime() + iPreviousUtcOffset < ASSrvStaticUtils::LocalTimeNow());

			}

		//Retrive the old local time before the time zone has been changed for the first skipped alarm.

		firstSkippedAlarmLocalTime = firstSkippedAlarmLocalTime + ServerData().CachedUtcOffset();

		TBool skippedAgendaAlarm(EFalse);

		// Tell every alarm that the date/time has changed

		const TInt count = QueueAlarmCount();

		TRAP_IGNORE(

                    for (TInt i = count - 1; i >= 0; i--)

                        {

                        TASSrvAlarm& alarm = QueueAlarmAt(i);

                        if (alarm.HandleDateTimeChangedL(aWorkdays, aWorkdaysChanged))

                            {

                            skippedAgendaAlarm = ETrue;	

                            }

                        }

                    )

		// If there was a skipped agenda alarm, publish the environment change and the details of the first

		// skipped alarm, otherwise, if there was a UTC offset change, only publish the environment change

		if (skippedAgendaAlarm)

			{

			PublishSkippedAlarm(ETrue);

			PublishAlarmedInstanceParams(firstSkippedAlarmLocalTime, aChanges & EChangesSystemTime);

			}

		else if (possibleHiddenFloatingAlarm)

			{

			PublishAlarmedInstanceParams(firstSkippedAlarmLocalTime, aChanges & EChangesSystemTime);			

			}

		else if (iPreviousUtcOffset != User::UTCOffset())

			{

			PublishSkippedAlarm(EFalse);

			}

#else

		// Tell every alarm that the date/time has changed

		const TInt count = QueueAlarmCount();

		TBool skippedAgendaAlarm = EFalse;

			TRAP_IGNORE(

	    		for (TInt i = count - 1; i >= 0; i--)

	    			{

	    			TASSrvAlarm& alarm = QueueAlarmAt(i);

	 				if (alarm.HandleDateTimeChangedL(aWorkdays, aWorkdaysChanged))

	    				{

	    				skippedAgendaAlarm = ETrue;	

	    				}

	   				}

			    )

		if (skippedAgendaAlarm || iPreviousUtcOffset != User::UTCOffset())

			{

			PublishSkippedAlarm(skippedAgendaAlarm);

			}

#endif		

		//Re sort the alarms after the above date/time change

  		TLinearOrder<TASSrvAlarm> order(ASSrvStaticUtils::CompareAlarms);

  		iAlarms.Sort(order);

		// Update floating alarms' due times.

		UpdateFloatingDueTimes();

		// When the date/time/locale changes we always simulate a change in the head item so that the timer will reset itself.

		const TAlarmId newHeadItemId = HeadAlarmId();

		NotifyEvent(MASSrvAlarmQueueObserver::EASSrvAlarmQueueEventHeadItemChanged, newHeadItemId);

		// Global any event notification

		ServerData().AnyEventManager().MASAnyEventManagerObserverNotifyChanges(EAlarmChangeEventSystemDateTimeChanged, KNullAlarmId);

		// Remove the dead alarms

		RemoveDeadAlarms();

		// And update the UTC offset			

		iPreviousUtcOffset = User::UTCOffset();

		}

	if	(aChanges & EChangesMidnightCrossover)

		{

		//Tidy up alarm queue every midnight

		RemoveDeadAlarms(); 

		}

	}

/**

 * Request notification when the state or status of an alarm changes

 */

void CASSrvAlarmQueue::RequestAlarmObservationEventsL(MASSrvAlarmObserver& aObserver)

	{

	User::LeaveIfError(iAlarmObservers.Append(TASSrvAlarmObserverMapplet(aObserver)));

	}

/**

 * Cancel a previous notification request

 */

void CASSrvAlarmQueue::RequestAlarmObservationEventsCancel(MASSrvAlarmObserver& aObserver)

	{

	const TInt count = iAlarmObservers.Count();

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

		{

		TASSrvAlarmObserverMapplet& mapplet = iAlarmObservers[i];

		if	(&mapplet.Observer() == &aObserver)

			{

			iAlarmObservers.Remove(i);

			return;

			}

		}

	}

/**

 * Temporarily enabled or disable notifications

 */

void CASSrvAlarmQueue::RequestAlarmObservationEventsEnabled(MASSrvAlarmObserver& aObserver, TBool aEnabled)

	{

	const TInt count = iAlarmObservers.Count();

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

		{

		TASSrvAlarmObserverMapplet& mapplet = iAlarmObservers[i];

		if	(&mapplet.Observer() == &aObserver)

			{

			mapplet.SetEnabled(aEnabled);

			return;

			}

		}

	ASSrvStaticUtils::Panic(ASSrvStaticUtils::EASSrvPanicNoMatchingObserver);

	}

/**

 * Adds the specified alarm to the alarm queue. Updates the alarm object

 * so that it contains a uniquely allocated id, suitable for clients to identify

 * this alarm amongst all others.

 */

void CASSrvAlarmQueue::QueueAlarmAndAllocateIdL(TASSrvAlarm& aAlarm, TAlarmId aSpecificAlarmId)

	{

	// Get the head id so that we know if the queue has changed

	const TAlarmId headItemId = HeadAlarmId();

	// Now allocate an id for the alarm. Doesn't matter if adding

	// the alarm fails (and therefore we orphan an Id - they can

	// be reused, as long as no current alarm shares the same id as 

	// another).

	const TAlarmId newId = aSpecificAlarmId == KNullAlarmId? NextFreeAlarmId() : aSpecificAlarmId;

	aAlarm.Id()=newId;

	// Add the alarm

	TASSrvAlarm* alarm = new(ELeave) TASSrvAlarm(ServerData());

	CleanupStack::PushL(alarm);

	*alarm = aAlarm;

	//

	TLinearOrder<TASSrvAlarm> order(ASSrvStaticUtils::CompareAlarms);

	User::LeaveIfError(iAlarms.InsertInOrderAllowRepeats(alarm, order));

	CleanupStack::Pop(alarm);

	// Change the state to queued

	TASSrvAlarm* newAlarm = QueueAlarmById(newId);

	newAlarm->SetState(EAlarmStateQueued);

	// Notify we've added an alarm

	NotifyEvent(MASSrvAlarmQueueObserver::EASSrvAlarmQueueEventAlarmAdded, newAlarm->Id());

	// Did the head item change?

	const TAlarmId newHeadItemId = HeadAlarmId();

	if	(newHeadItemId != headItemId)

		{

		// Head item has changed. The timer will pick up the change and requeue itself

		// for the new alarm.

		NotifyEvent(MASSrvAlarmQueueObserver::EASSrvAlarmQueueEventHeadItemChanged, newHeadItemId);

		}

	ServerData().AnyEventManager().MASAnyEventManagerObserverNotifyChanges(EAlarmChangeEventAlarmAddition, newId);

	}

/**

 * Releases a previously allocated alarm. Removes it from the queue, and if this

 * alarm was at the head of the queue, a new alarm is promoted.

 */

void CASSrvAlarmQueue::DeQueueAlarm(const TASSrvAlarm& aAlarm)

	{

	const TAlarmId id = aAlarm.Id();

	const TBool isHeadItem = (id == HeadAlarmId());

	// Find index from alarm

	TIdentityRelation<TASSrvAlarm> identityRelation(ASSrvStaticUtils::CompareAlarmsExact);

	const TInt errorOrIndex = iAlarms.Find(&aAlarm, identityRelation);

	__ASSERT_ALWAYS(errorOrIndex != KErrNotFound, ASSrvStaticUtils::Fault(ASSrvStaticUtils::EASSrvFaultAlarmNotFound));

	// Inform alarm it's being destroyed

	TASSrvAlarm* alarm = &QueueAlarmAt(errorOrIndex);

	__ASSERT_ALWAYS(alarm->Id() == aAlarm.Id(), ASSrvStaticUtils::Panic(ASSrvStaticUtils::EASSrvPanicAttemptingToDequeWrongAlarm));

	alarm->HandleDeQueue();

	// DEBUG_PRINT_QUEUE("ALARMSERVER Before removing item")

	// Remove from queue

#ifdef _DEBUG

	const TInt count = QueueAlarmCount();

#endif

	iAlarms.Remove(errorOrIndex);

	delete alarm;

	__ASSERT_DEBUG(iAlarms.Count() == count-1, ASSrvStaticUtils::Panic(ASSrvStaticUtils::EASSrvPanicAlarmNotDeQueued));

	// DEBUG_PRINT_QUEUE("ALARMSERVER After removing item")

	// Notify we've deleted an alarm

	NotifyEvent(MASSrvAlarmQueueObserver::EASSrvAlarmQueueEventAlarmDeleted, id);

	// DEBUG_PRINT_QUEUE("ALARMSERVER After notifying event")

	// Notify change

	ServerData().AnyEventManager().MASAnyEventManagerObserverNotifyChanges(EAlarmChangeEventAlarmDeletion, id);

	// DEBUG_PRINT_QUEUE("ALARMSERVER After notifying any event")

	if	(isHeadItem)

		{

		// Head item has changed. The timer will pick up the change and requeue itself

		// for the new alarm.

		const TAlarmId newHeadItem = HeadAlarmId();

		NotifyEvent(MASSrvAlarmQueueObserver::EASSrvAlarmQueueEventHeadItemChanged, newHeadItem);

		// DEBUG_PRINT_QUEUE("ALARMSERVER After head item changed")

		}

	}

/**

 * Returns the alarm at the head of the queue or NULL if there is none.

 */

const TASSrvAlarm* CASSrvAlarmQueue::HeadAlarm() const

	{

	// There is a head alarm if there is at least one alarm in the queue

	// and that alarm is not disabled.

	CASSrvAlarmQueue& self = const_cast<CASSrvAlarmQueue&>(*this);

	// Create & open primary iterator

	RASSrvIteratorByStatus primaryIterator(self, EAlarmStatusEnabled);

	primaryIterator.Open();

	// Create and attach secondary iterator

	RASSrvIteratorByState secondaryIterator(self, EAlarmStateQueued, EAlarmStateSnoozed);

	primaryIterator.IteratorAttach(secondaryIterator);

	if (primaryIterator.NextAlarmAvailable())

		{

		return QueueAlarmById(primaryIterator.NextAlarm().Id());

		}

	else

		{

		return NULL;

		}

	}

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS	

/**

 * Returns the calendar alarm at the head of the queue

 */

TAlarmId CASSrvAlarmQueue::HeadCalendarAlarmId() const

	{

	CASSrvAlarmQueue& self = const_cast<CASSrvAlarmQueue&>(*this);

	// Create & open primary iterator

	RASSrvIteratorByStatus primaryIterator(self, EAlarmStatusEnabled);

	primaryIterator.Open();

	// Create and attach secondary iterator

	RASSrvIteratorByState secondaryIterator(self, EAlarmStateQueued, EAlarmStateSnoozed);

	primaryIterator.IteratorAttach(secondaryIterator);

	// The category for calendar alarms is defined in caalarm.h and is

	// reproduced here to avoid a dependency on the calendar server

	const TUid KUidAgendaModelAlarmCategory = { 0x101F4A70 };

	// Create and attach tertiary iterator

	RASSrvIteratorByCategory tertiaryIterator(self, KUidAgendaModelAlarmCategory);

	primaryIterator.IteratorAttach(tertiaryIterator);

	TAlarmId returnAlarmId(KNullAlarmId);

	if (primaryIterator.NextAlarmAvailable())

		{

		returnAlarmId = primaryIterator.NextAlarm().Id();

		}

	return returnAlarmId;

	}

#endif

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

/**

 * Returns the alarm id of the head wakeup alarm of the queue

 */

TAlarmId CASSrvAlarmQueue::HeadWakeupAlarmId() const

	{

	// There is a head alarm if there is at least one alarm in the queue

	// and that alarm is not disabled.

	CASSrvAlarmQueue& self = const_cast<CASSrvAlarmQueue&>(*this);

	// Create & open primary iterator

	RASSrvIteratorByStatus primaryIterator(self, EAlarmStatusEnabled);

	primaryIterator.Open();

	// Create and attach secondary iterator

	RASSrvIteratorByState secondaryIterator(self, EAlarmStateQueued, EAlarmStateSnoozed);

	primaryIterator.IteratorAttach(secondaryIterator);

	// Create and attach tertiary iterator	

	RASSrvIteratorByWakeup tertiaryIterator(self);

	secondaryIterator.IteratorAttach(tertiaryIterator);

	TAlarmId returnAlarmId(KNullAlarmId);

	if (primaryIterator.NextAlarmAvailable())

		{

		returnAlarmId = primaryIterator.NextAlarm().Id();

		}

	return returnAlarmId;

	}

#endif

/**

 * Returns the id of the alarm at the head of the queue, or if there isn't a head alarm returns KNullAlarmId

 */

TAlarmId CASSrvAlarmQueue::HeadAlarmId() const

	{

	TAlarmId headItemId = KNullAlarmId;

	const TASSrvAlarm* headAlarm = HeadAlarm();

	if	(headAlarm)

		{

		headItemId = headAlarm->Id();

		}

	return headItemId;

	}

/**

 * Called whenever a session logs off. All session-specific alarm should be removed in this instance.

 */

void CASSrvAlarmQueue::RemoveAllSessionAlarmsBySessionId(TASSrvSessionId aSessionId)

	{

	const TInt count = QueueAlarmCount();

	for(TInt i=count-1; i>=0; i--)

		{

		const TASSrvAlarm& alarm = QueueAlarmAt(i);

		if	(alarm.OriginatingSessionId() == aSessionId && alarm.Characteristics().IsSet(EAlarmCharacteristicsSessionSpecific))

			DeQueueAlarm(alarm);

		}

	}

/**

 * Generates and returns the next valid alarm id.

 */

TAlarmId CASSrvAlarmQueue::NextFreeAlarmId()

	{

	if	(iNextFreeAlarmId == KMaxTInt)

	    {

	    iNextFreeAlarmId = 1; // Zero is special - "No alarm id"

	    }

	else

	    {

	    ++iNextFreeAlarmId;

	    }

	// Generate a unique alarm Id.

	while(AlarmIdIsInUse(iNextFreeAlarmId))

		{

		if	(iNextFreeAlarmId == KMaxTInt)

		    {

		    iNextFreeAlarmId = 1;

		    }

		else

		    {

		    ++iNextFreeAlarmId;

		    }

		}

	return iNextFreeAlarmId;

	}

/**

 * Specify type of Store (or Internalize) operation wanted:

 * 1. Externalize

 *		- synchronous write of alarm queue and related information to file.

 * 2. Internalize after Startup or Restore 

 *		- synchronous read of alarm queue and related information from file.

 * 3. Backup

 */

TInt CASSrvAlarmQueue::StartAlarmStoreOperation(TStoreOperation aStoreOperation)

	{

	TInt error = KErrNone;