// 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 __ASSRVSTATICUTILS_H__
#define __ASSRVSTATICUTILS_H__
// System includes
#include <e32base.h>
#include <s32strm.h>
#include <f32file.h>
// User includes
#include <asshddefs.h>
#include "ASSrvAlarmSoundDetails.h"
// Classes referenced
class TASSrvAlarm;
class TASShdAlarm;
//
// ----> ASSrvStaticUtils (header)
//
/**
* Global utility functions
*/
class ASSrvStaticUtils
{
//
public: // PANIC/FAULT ENUMERATIONS
//
/**
* For DEBUG-ONLY panics
*/
enum TASSrvFault
{
/**
* A default section of a switch statement relating to alarm
* states has been hit
*/
EASSrvFaultAlarmStateNotHandled = 0,
/**
* Timer event not handled in switch statement
*/
EASSrvFaultTimerEventNotHandled = 1,
/**
* The alarm data for the specified alarm couldn't be
* found, when it should be available
*/
EASSrvFaultAlarmDataEntryNotFound = 2,
/**
* There wasn't any alarm data when there should have been
*/
EASSrvFaultNoData = 3,
/**
* Some kind of timing error took place which was unexpected
*/
EASSrvFaultPhantomErrorReported = 4,
/**
* An alarm status wasn't handled in a switch statement
*/
EASSrvFaultAlarmStatusNotHandled = 5,
/**
* An iterator has attempted to attach itself to itself
*/
EASSrvFaultCyclicIteratorAttach = 6,
/**
* The alarm wasn't found when it should have been
*/
EASSrvFaultAlarmNotFound = 7,
/**
* The index specified within the sound intervals
* list isn't valid
*/
EASSrvFaultBadSoundIntervalIndex = 8,
/**
* A facade interface wasn't reimplemented
*/
EASSrvFaultFacadeInterfaceError = 9,
/**
* An invalid alarm alert server response was received
*/
EASSrvFaultInvalidAlarmAlertServerResponse = 10,
/**
* The alarm alert server response handler already
* has an outstanding request with the alarm alert server.
*/
EASSrvFaultAlarmAlertServerResponseReaderAlreadyActive = 11,
/**
* A fault condition occurred within the alarm alert
* server client code
*/
EASSrvFaultAlarmAlertServerFault = 12,
/**
* The flags passed to/from the alarm alert server
* are invalid
*/
EASSrvFaultAlarmAlertSetFlagsWithInappropriateValue = 13,
/**
* Alarm Queue StartAlarmStoreOperation called with invalid store operation
*/
EASSrvFaultStartInvalidAlarmStoreOperation = 14,
/**
* Alarm Queue EndAlarmStoreOperation called with invalid store operation
*/
EASSrvFaultEndInvalidAlarmStoreOperation = 15,
/**
* An alarm has sound paused while there is another alarm in notifying state.
*/
EASSrvFaultInvalidSoundPauseAlarm = 16,
/**
* Alarm server tries to notify more than max number of allowed alarm.
*/
EASSrvFaultNotifyAlarmExceedMax = 17,
/**
* Alarm server has no notifying alarms.
*/
EASSrvFaultNoNotifyingAlarms = 18,
/**
* Marker
*/
EASSrvFaultLast
};
/**
* For ASSERT-ALWAYS panics
*/
enum TASSrvPanic
{
/**
* A next alarm for a given iterator
* was expected but not available
*/
EASSrvPanicNoNextAlarmForIterator = 0,
/**
* The alarm specified by the given id
* doesn't exist
*/
EASSrvPanicNoAlarmForId = 1,
/**
* The specified queue observer could not be
* located
*/
EASSrvPanicNoMatchingObserver = 2,
/**
* A iterator chaining function was executed
* but no attached iterator was found
*/
EASSrvPanicNoAttachedIterator = 3,
/**
* It wasn't possible to update the status
* of the given alarm
*/
EASSrvPanicCannotSetAlarmStatus = 4,
/**
* An invalid or unexpected repeat definition
* was encountered
*/
EASSrvPanicInvalidAlarmRepeat = 5,
/**
* The specified alarm wasn't removed from
* the alarm server queue
*/
EASSrvPanicAlarmNotDeQueued = 6,
/**
* It wasn't possible to start the alarm
* server's active scheduler
*/
EASSrvPanicSchedulerNotStarted = 7,
/**
* An invalid backup operation was initiated
*/
EASSrvPanicInvalidBackupOperation = 8,
/**
* A request to start notifications about
* a given alarm do not match that which is
* expected.
*/
EASSrvPanicNotifyingAboutWrongAlarm = 9,
/**
* An alarm iterator function has
* encountered a null alarm id
*/
EASSrvPanicIteratorAlarmIdNull = 10,
/**
* An alarm has attempted to notify itself
* when it is already in the notifying state.
*/
EASSrvPanicAlarmRepeatedlyNotifying = 11,
/**
* The wrong alarm id has been promoted to the
* notifying state
*/
EASSrvPanicNotifyingAlarmIsNotAlertingAlarm = 12,
/**
* An invalid alarm state was encountered
*/
EASSrvPanicInvalidAlarmState = 13,
/**
* It wasn't possible to complete the two-phase idle
* construction of the notification co-ordinator
*/
// EASSrvPanicNotificationCoordinatorConstructionIncomplete = 14, // not used any more
/**
* An invalid observer event was encountered
*/
EASSrvPanicInvalidTObserverEvent = 15,
/**
* An unexpected null alarm id was encountered
*/
EASSrvPanicQueueAlarmIdNull = 16,
/**
* The current alarm id managed by the notification
* co-ordinator does not match that of the currently
* notifying alarm
*/
EASSrvPanicCurrentAlarmNotNotifyingAlarm = 17,
/**
* Two or more alarms are trying to notify at
* the same time
*/
EASSrvPanicMoreThanOneAlarmNotifying = 18,
/**
* An unexpected or invalid TSoundSettings event
* was encountered
*/
EASSrvPanicInvalidTSoundSettingsEvent = 19,
/**
* A request has been made to delete an alarm
* but its id doesn't match the expected value
*/
EASSrvPanicAttemptingToDequeWrongAlarm = 20,
/**
* An Internalize() request has been made without
* correctly setting the type of request.
*/
EASSrvPanicInternalizeTypeInvalid = 21,
/**
* OutOfMemory
*/
EASSrvPanicOutOfMemory= 22,
/**
* Alarm server sound controller received an unexpected event while disabled.
*/
EASSrvPanicUnexpectedEventSoundControllerDisabled = 23,
/**
* Marker
*/
EASSrvPanicLast
};
//
public: // STATIC UTILITY FUNCTIONS
//
static TInt ValidateAlarm(TASSrvAlarm& aAlarm);
static TInt ValidateSoundPlayIntervals(RArray<TASSrvAlarmSoundDetails>& aIntervals);
static void Fault(TASSrvFault aFault);
static void Panic(TASSrvPanic aPanic);
static TInt CompareCategories(const TAlarmCategory& aCategory1, const TAlarmCategory& aCategory2);
static TInt CompareAlarmIds(const TAlarmId& aId1, const TAlarmId& aId2);
static TInt CompareAlarms(const TASSrvAlarm& aAlarm1, const TASSrvAlarm& aAlarm2);
static TBool CompareAlarmsExact(const TASSrvAlarm& aAlarm1, const TASSrvAlarm& aAlarm2);
static TVersion ASVersion();
static const TDesC& ASName();
static void RoundTimeDownToTheMinute(TTime& aTime);
static void PanicClient(const RMessage2& aMessage, TAlarmServerInitiatedClientPanic aPanic);
static TTime UtcTimeNow();
static TTime LocalTimeNow();
static void TodayAtTheSpecifiedTime(const TTime& aTime, TTime& aReturn);
static RArray<TASSrvAlarmSoundDetails>* InternalizeSoundPlayIntervalsLC(RReadStream& aStream);
static void GetPrivateDirL(RFs& aFsSession, TDes& aDirName);
static void GetServerPathL(RFs& aFsSession, TDes& aFileName);
static void DaysUntilNextActiveAlarmDay(TTimeIntervalDays& aDaysFromNow, TTimeIntervalDays& aRollOverDays, TDay aCurrentDayInWeek, TUint aActiveDays);
static void CalculateNext24HoursRepeat(TASShdAlarm& aAlarm, TTimeIntervalSeconds aAllowableWindow = 0);
static void CleanupCloseDeleteAlarmIdArray(TAny* aArray);
static void CleanupCloseDeleteCategoryArray(TAny* aArray);
static void CleanupCloseDeleteSoundDetailsArray(TAny* aArray);
//
private: // INTERNAL FUNCTIONS
//
static TInt CompareSoundPlayIntervalStartTimes(const TASSrvAlarmSoundDetails& aAlarmSound1, const TASSrvAlarmSoundDetails& aAlarmSound2);
static TBool SoundPlayIntervalsOverlap(const TASSrvAlarmSoundDetails& aDetails1, const TASSrvAlarmSoundDetails& aDetails2);
};
/**
* Template classes to call ResetAndDestroy on array classes
* automatically, when ::PopAndDestroy'ing from the cleanup stack.
*/
template <class T>
class CleanupResetAndDestroy
{
public:
inline static void PushL(T& aRef);
private:
static void ResetAndDestroy(TAny *aPtr);
};
template <class T>
inline void CleanupResetAndDestroyL(T& aRef);
// Template class CleanupClose
template <class T>
inline void CleanupResetAndDestroy<T>::PushL(T& aRef)
{CleanupStack::PushL(TCleanupItem(&ResetAndDestroy, &aRef));}
template <class T>
void CleanupResetAndDestroy<T>::ResetAndDestroy(TAny *aPtr)
{static_cast<T*>(aPtr)->ResetAndDestroy();}
template <class T>
inline void CleanupResetAndDestroyPushL(T& aRef)
{CleanupResetAndDestroy<T>::PushL(aRef);}
#endif