diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Server/Include/ASSrvSoundController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmserver/Server/Include/ASSrvSoundController.h Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,312 @@ +// 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: +// + +#ifndef __ASSRVSOUNDCONTROLLER_H__ +#define __ASSRVSOUNDCONTROLLER_H__ + +// System includes +#include +#include + +// User includes +#include +#include "ASSrvAlarmObserver.h" +#include "ASSrvAlarmQueueObserver.h" +#include "ASSrvSoundSettingsObserver.h" +#include "ASSrvSoundControllerObserver.h" +#include "ASSrvEnvironmentChangeObserver.h" + +// Classes referenced +class TASSrvAlarm; +class CASSrvServerWideData; +class MASSrvSoundControllerObserver; + + +// +// ----> CASSrvSoundController (header) +// +/** + * The sound controller performs all the timing related functionality associated + * with the sound play intervals (these essentially are "auto-snoozed" alarm sounds, + * whereby after a given length of time, the alarm sound is silenced for a small + * amount of time). For example, the sound plays for 30 seconds, then is silent + * for 30, then it plays again for 30 seconds, and then is slient for 1 minute, etc. + * + * The sound controller notifies an observer which actually implements the sound + * playing functionality (in fact, the observer is just a proxy for the Alarm + * Alert Server, where the sound is really played). + */ +class CASSrvSoundController : public CTimer, + public MASSrvAlarmObserver, + public MASSrvSoundSettingsObserver, + public MASSrvAlarmQueueObserver, + public MASSrvEnvironmentChangeObserver + { +// +public: // STATIC CONSTRUCT / DESTRUCT +// + static CASSrvSoundController* NewL(CASSrvServerWideData& aServerWideData, MASSrvSoundControllerObserver& aObserver); + ~CASSrvSoundController(); + +// +private: // INTERNAL CONSTRUCT +// + CASSrvSoundController(CASSrvServerWideData& aServerWideData, MASSrvSoundControllerObserver& aObserver); + void ConstructL(); + +// +private: // FROM MASSrvAlarmObserver +// + + /** + * @see MASSrvAlarmObserver + * + * When an alarm expires, we should start timing the alarm sound intervals. Note that + * no sound is played directly by the alarm server - it's all handled by proxy in the + * EikSrv thread (Alarm Alert Server). + * + * We only ever receive one notification that an alarm has expired (unless its snoozed + * and then the snooze expires). Therefore, the sound controller has to perform cycle + * management for the alerting (notifying) head alarm in the queue). + */ + void MASSrvAlarmObsHandleEvent(TObserverEvent aEvent, const TASSrvAlarm& aAlarm, TInt aEventSpecificData); + +// +private: // FROM MASSrvSoundSettingsObserver +// + + /** + * @see MASSrvSoundSettingsObserver + */ + void MASSoundSettingsHandleChangeEvent(TSoundSettingsEvent aEvent); + +// +private: // FROM MASSrvAlarmQueueObserver +// + + /** + * @see MASSrvAlarmQueueObserver + */ + void MAlarmQueueObserverHandleEvent(TASSrvAlarmQueueEvent aEvent, TAlarmId aAlarmId); + +// +private: // FROM MASSrvEnvironmentChangeObserver +// + + /** + * @see MASSrvEnvironmentChangeObserver + * + * Since PREQ234 all alarm silent periods are stored in UTC time but specified in + * local time hence the need to track changes to system time. + */ + + void MEnvChangeHandleEvent(TInt aChanges, TUint aWorkdays, TBool aWorkdaysChanged); + +// +public: // ACCESS +// + + /** + * Stops any sound from playing and resets the sound timer to an idle state. + */ + void CancelAllSounds(); + + /** + * Stop playing any sounds until the specified time updating with UTC offset changes. + */ + void MakeAllSoundsQuietUntil(const TTime& aTime); + + /** + * Returns the + */ + inline const TTime& SoundsQuietUntil() const { return iTimeToReturnToNormalSoundTimingBehaviour; } + + /** + * Stop playing the sound (for just this alarm) until the specified time. + */ + void CurrentAlarmSoundPausedUntil(const TTime& aTime); + + /** + * Returns a boolean indicating whether or not the alarm server is currently + * in a quiet period. + */ + TBool InQuietPeriod() const; + + /** + * Return a boolean indicating whether sound is currently + * paused within the alarm server. + */ + TBool SoundIsPausedForAlarm() const; + + /** + * Cancel a previously enabled silent period + */ + void CancelSilence(); + + /** + * Do not update silent period with UTC offset changes. + */ + inline void SetFixed() { Flags().Set(ESoundControllerFlagsIsFixed); } + + /** + * Update silent period with UTC offset changes. + */ + inline void SetFloating() { Flags().Clear(ESoundControllerFlagsIsFixed); } + + void CancelSound(TAlarmId aAlarmId); + +// +private: // FROM CActive +// + + /** + * @see CActive + */ + void RunL(); + + /** + * Replacement of CActive::Cancel function + */ + void Cancel(); + +// +private: // INTERNAL +// + + /** + * Access the server wide data + */ + inline CASSrvServerWideData& ServerData() const { return iServerWideData; } + + /** + * Writable access to this class' interal flags + */ + inline TBitFlags& Flags() { return iSoundControllerFlags; } + + /** + * Access to this class' interal flags + */ + inline const TBitFlags& Flags() const { return iSoundControllerFlags; } + + /** + * Writable access to the id of the currently notifying alarm + */ + inline TAlarmId& IdOfNotifyingAlarm() { return iIdOfNotifyingAlarm; } + + /** + * The id of the currently notifying alarm + */ + inline TAlarmId IdOfNotifyingAlarm() const { return iIdOfNotifyingAlarm; } + + /** + * Handle a timer event - called when the sound timer expires + */ + void ReactToSoundTimerExpiry(); + + /** + * Notify observers about the specified event + */ + void NotifySoundEvent(MASSrvSoundControllerObserver::TSoundControllerEvent aEvent, TAlarmId aAlarmId); + + /** + * Manage sound timing + */ + void StartSoundTimingForAnyWaitingAlarmAfterPausingOrQuietPeriod(); + + /** + * Calculate when the next start/stop timer period should be for + * alarm sounds + */ + void WorkOutAndScheduleForNextSoundCycle(); + + /** + * Indicates that the Sound Controller is disabled (ie. no sounds + * intervals configured in the rsc file) + */ + TBool IsSoundControllerDisabled() const; + + + void PlayPreviousNotifyingAlarm(); + +// +private: // INTERNAL ENUMERATIONS +// + /** + * Internal sound flags + */ + enum TSoundControllerFlags + { + /** + * Pausing + */ + ESoundControllerFlagsPausing = 0, + + /** + * Quiet period + */ + ESoundControllerFlagsInQuietPeriod = 1, + + /** + * Until (floating) or For (fixed) silent period + */ + + ESoundControllerFlagsIsFixed = 2, + }; + +// +private: // MEMBER DATA +// + + /** + * The alarm id of the alarm which is currently being timed. KNullAlarmID if + * no current alarm to notify. + */ + TAlarmId iIdOfNotifyingAlarm; + + /** + * Record the previous sound event we sent to the SoundControlllerObserver + * (and AlertServer) so that we can suppress duplicate events. + */ + MASSrvSoundControllerObserver::TSoundControllerEvent iPreviousSoundEvent; + + /** + * The time when normal sound behaviour should be resumed. + */ + TTime iTimeToReturnToNormalSoundTimingBehaviour; + + /** + * Internal flags + */ + TBitFlags iSoundControllerFlags; + + /** + * The server wide data handle + */ + CASSrvServerWideData& iServerWideData; + + /** + * The observer of this class, in this case, the notification + * co-ordinator + */ + MASSrvSoundControllerObserver& iObserver; + + /** + * UTC offset when the last request involving time was made + */ + + TTimeIntervalSeconds iPreviousUTCOffset; + }; + +#endif