diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Server/Include/ASSrvAlarmQueue.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmserver/Server/Include/ASSrvAlarmQueue.h Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,310 @@ +// 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 +#endif + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS + #include +#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 iAlarmObservers; + /** + * The list of all alarms within the server. + */ + RPointerArray iAlarms; + /** + * A list of observes who are interested in queue change notifications. + */ + RPointerArray iNotificationList; + + /** + * Type of Alarm Store operation being performed + */ + TStoreOperation iStoreOperation; + + /** + * Internalize buffers for data. used/discarded by ApplyInternalizedData() method + */ + TAlarmId iInternalizeNextFreeAlarmId; + RPointerArray 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