// 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: The header contains class declaration for alarm queue class used

//              for holding all the alarms in the alarm server.

//

#ifndef __ASSRVALARMQUEUE_H__

#define __ASSRVALARMQUEUE_H__

// User Includes

#include "ASSrvDefs.h"

#include "ASSrvAlarm.h"

#include "ASSrvStaticUtils.h"

#include "ASSrvTimerObserver.h"

#include "ASSrvAlarmObserver.h"

#include "ASSrvAlarmQueueObserver.h"

#include "ASSrvEnvironmentChangeObserver.h"

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

    #include <ssm/ssmadaptationcli.h>

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    #include <ASShdAlarmCal.h>

#endif

// Classes Referenced

class MASSrvAlarmObserver;

class CASSrvServerWideData;

class CASSrvDSTChange;

/**

 * The overall container class for all alarms maintained within the Alarm Server.

 */

class CASSrvAlarmQueue :  public CBase, public MASSrvEnvironmentChangeObserver

	{

public:

	static CASSrvAlarmQueue* NewL(CASSrvServerWideData& aServerWideData);

	~CASSrvAlarmQueue();

private:									

	CASSrvAlarmQueue(CASSrvServerWideData& aServerWideData);

	void ConstructL();

private:									

    // from MASSrvEnvironmentChangeObserver

	void MEnvChangeHandleEvent(TInt aChanges, TUint aWorkdays, TBool aWorkdaysChanged);

public:

    // from MASSrvAlarmInfoProvider

	TInt ASSrvAlarmInfoCount() const;

	void ASSrvAlarmInfoAt(TInt aIndex, TASSrvAlarm& aAlarm) const;

public:										

    // Notification Management

	void NotificationPoolChangeL(MASSrvAlarmQueueObserver& aObserver);

	void NotificationPoolChangeCancel(MASSrvAlarmQueueObserver& aObserver);

public:										

    // Access - Alarm Observation

	void RequestAlarmObservationEventsL(MASSrvAlarmObserver& aObserver);

	void RequestAlarmObservationEventsCancel(MASSrvAlarmObserver& aObserver);

	void RequestAlarmObservationEventsEnabled(MASSrvAlarmObserver& aObserver, TBool aEnabled);

public:										

    // Queue Access

	TInt QueueAlarmCount() const;

	TASSrvAlarm& QueueAlarmAt(TInt aIndex);

	const TASSrvAlarm& QueueAlarmAt(TInt aIndex) const;

	TInt QueueAlarmById(TAlarmId aId, TASSrvAlarm& aAlarm) const;

	TASSrvAlarm* QueueAlarmById(TAlarmId aId);

	const TASSrvAlarm* QueueAlarmById(TAlarmId aId) const;

	TASSrvAlarm& QueueAlarmByIdL(TAlarmId aId);

	const TASSrvAlarm& QueueAlarmByIdL(TAlarmId aId) const;

public:										

    // Access

	void QueueAlarmAndAllocateIdL(TASSrvAlarm& aAlarm, TAlarmId aSpecificAlarmId = KNullAlarmId);

	void DeQueueAlarm(const TASSrvAlarm& aAlarm);

	const TASSrvAlarm* HeadAlarm() const;

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS	

	TAlarmId HeadCalendarAlarmId() const;

#endif

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	TAlarmId HeadWakeupAlarmId() const;

#endif

	TAlarmId HeadAlarmId() const;

	void RemoveAllSessionAlarmsBySessionId(TASSrvSessionId aSessionId);

	TAlarmId NextFreeAlarmId();

	TBool HaveAdditionalAlarmsToNotify();

	TInt NumberOfAlarmsPendingNotification();

	TASSrvAlarm& NextAlarmWaitingForNotification();

public:										

    // Store Framework

	void InternalizeL(RReadStream& aStream);

	void ExternalizeL(RWriteStream& aStream) const;

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS	

	void InternalizeLastAlarmedInstanceParamsL(RReadStream& aStream);

	void ExternalizeLastAlarmedInstanceParamsL(RWriteStream& aStream) const;

#endif	

public:										

    // Support for store framework

	/**

	 * The next/current Alarm Store operation

	 */

	enum TStoreOperation

		{

		/**

		 * No-op state

		 */

		EStoreIdle = 0,

		/**

		 * Attempt to Internalize after system start

		 */

		EStoreInternalizeStartup,

		/**

		 * Attempt to Internalize after a backup restore

		 */

		EStoreInternalizeRestore,

		/**

		 * Externalize (e.g. Alarms have changed, Alarm Sound Settings have changed

		 * or Alarm Server shutdown)

		 */

		EStoreExternalize,

		/**

		 * Backup - Read access to AlarmServer.ini file requested for backup

		 * (by backup/synchronisation app.)

		 */

		EStoreBackup,

		/**

		 * Restore - Exclusive Write access to AlarmServer.ini file requested for Restore

		 * (by backup/synchronisation app.)

		 */

		EStoreRestore

		};

	TInt StartAlarmStoreOperation(TStoreOperation aStoreOperation);

	void EndAlarmStoreOperation(TInt aError);

	/**

	 * Check that Alarm and Alarm Data is writable.

	 */

	void CheckAlarmQueueWritableL();

public:										

    // Event Handlers - called by TASSrvAlarm

	void HandleAlarmStatusChanged(TAlarmId aAlarmThatChangedStatus, TAlarmStatus aOldStatus);

	void HandleAlarmStateChanged(TAlarmId aAlarmThatChangedState, TAlarmState aOldState);

	void HandleAlarmCharacteristicsChanged(TAlarmId aAlarmThatChangedCharacteristics, TAlarmCharacteristicsFlags aOldCharacteristics);

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	void HandleWakeupChanged(TAlarmId aAlarmThatChangedWakeup);

#endif

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS

	void HandleAlarmDaysChanged(TAlarmId aAlarmThatChangedDays);

#endif

	void HandleAlarmDataChanged(TAlarmId aAlarmThatChangedData);

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

public:

	void HandleNextDSTChangeEventL();

	void UpdateRTC();

#endif

private:									

    // Internal

	inline CASSrvServerWideData& ServerData() const { return iServerWideData; }

	TBool AlarmIdIsInUse(TAlarmId aAlarmId) const;

	void RemoveDeadAlarms();

	void NotifyAlarmObserverEvent(MASSrvAlarmObserver::TObserverEvent aEvent, const TASSrvAlarm& aAlarm, TInt aEventSpecificData);

	void NotifyEvent(MASSrvAlarmQueueObserver::TASSrvAlarmQueueEvent aEvent, TAlarmId aAlarmId);

	void ReplaceQueueWithInternalizedQueue();

	void ApplyInternalizedData(TBool aUseNewData);

	void UpdateFloatingDueTimes();

	void PublishSkippedAlarm(TBool aSkippedCalAlarm);

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS	

	void PublishAlarmedInstanceParams(const TTime& aFirstSkippedAlarmLocalTime, TBool aSystemTimeChange);

	void PublishAlarmedInstanceParams(const TASShdAlarmedInstanceParams& aAlarmedInstanceParams);

#endif

private:									

    // Internal Classes

	/**

	 * A mapping between alarm observers and enabled states. Allows an observer

	 * to temporarily disable notification events without being removed from

	 * the observer array. This prevents OOM problems since observers don't

	 * have to run the risk of a leave (due to no memory) when re-requesting

	 * observations.

	 */

	class TASSrvAlarmObserverMapplet

		{

	public:

		inline TASSrvAlarmObserverMapplet(MASSrvAlarmObserver& aObserver) : iEnabled(ETrue), iObserver(&aObserver) { }

		/**

		 * Access the observer.

		 */

		inline MASSrvAlarmObserver& Observer() { return *iObserver; }

		/**

		 * Does this observer want to receive notification events?

		 */

		inline TBool IsEnabled() const { return iEnabled; }

		/**

		 * Change the enabled status of the observer.

		 */

		inline void SetEnabled(TBool aEnabled) { iEnabled = aEnabled; }

	private:

		/**

		 * Wehther or not the observer wants to receive notifications.

		 */

		TBool iEnabled;

		/**

		 * The observer itself.

		 */

		MASSrvAlarmObserver* iObserver;

		};

private:									

	/**

	 * The server wide data.

	 */

	CASSrvServerWideData& iServerWideData;

	/**

	 * The next free alarm Id.

	 */

	TAlarmId iNextFreeAlarmId;

	/**

	 * The array of alarm observers.

	 */

	RArray<TASSrvAlarmObserverMapplet> iAlarmObservers;

	/**

	 * The list of all alarms within the server.

	 */

	RPointerArray<TASSrvAlarm> iAlarms;

	/**

	 * A list of observes who are interested in queue change notifications.

	 */

	RPointerArray<MASSrvAlarmQueueObserver>	iNotificationList;

	/**

	 * Type of Alarm Store operation being performed

	 */

	TStoreOperation iStoreOperation;

	/**

	 * Internalize buffers for data. used/discarded by ApplyInternalizedData() method

	 */

	TAlarmId iInternalizeNextFreeAlarmId;

	RPointerArray<TASSrvAlarm> iInternalizeAlarmQueue;

	/**

	 * The previous UTC offset for checking whether it has changed while the Alarm

	 * Server was down.

	 */

	TTimeIntervalSeconds iPreviousUtcOffset;

	/**

	 * Details about the next DST change.

	 */

	CASSrvDSTChange* iASSrvDSTChange;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	/**

	 * Handle to the  real-time-clock so that we can set wakeup alarms.

	 */

	RSsmRtcAdaptation iSsmRtcAdaptation;

#endif

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS	

	/**

	 * Stores the last published value of the skipped alarm data.

	 */

	TASShdAlarmedInstanceParams iLastAlarmedInstanceParams;

#endif	

	};

#endif