// 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:

//

#include "ASSrvAlarm.h"

// User includes

#include "ASSrvTimer.h"

#include "ASSrvDataPool.h"

#include "ASSrvAlarmQueue.h"

#include "ASSrvStaticUtils.h"

#include "ASSrvSoundSettings.h"

#include "ASSrvServerWideData.h"

#include "ASSrvAlarmSoundDetails.h"

#include "ASSrvIteratorByState.h"

#include "ASSrvSoundController.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "ASShdAlarm_internal.h"

#endif

// Definitions

//#define __DEBUGGING_TIMES

//

// ----> TASSrvAlarm (source)

//

//*************************************************************************************

/**

 * Constructor

 */

TASSrvAlarm::TASSrvAlarm(CASSrvServerWideData& aData)

:	iSoundPeriodCycleNumber(KUndefinedCycleIndex), iStartTimeForSoundCalculations(Time::NullTTime()),

	iSoundState(ESoundStatePlayingNothing), iInternalServerFlags(0),

	iOriginatingSessionId(KErrNotFound), iServerWideData(aData)

	{

	}

//

//

//

//*************************************************************************************

/**

 * Copy operator. Only copies certain data members. Possibly this

 * should be removed...

 */

TASSrvAlarm& TASSrvAlarm::operator=(const TASSrvAlarm& aAlarm)

	{

	TASShdAlarm::operator=(aAlarm);

	//

	iSoundPeriodCycleNumber = aAlarm.iSoundPeriodCycleNumber;

	iStartTimeForSoundCalculations = aAlarm.iStartTimeForSoundCalculations;

	iSoundState = aAlarm.iSoundState;

	iInternalServerFlags = aAlarm.iInternalServerFlags;

	iOriginatingSessionId = aAlarm.iOriginatingSessionId;

	iNotificationMessage = aAlarm.iNotificationMessage;

	//

	return *this;

	}

//

//

//

//*************************************************************************************

/**

 * Change the status of this alarm, i.e. enabled, disabled

 *

 * @return  TInt KErrNone on success, or one of the system wide standard error codes.

 *				 KErrLocked is returned if this alarm is a "workday" alarm but no valid

 *				 workdays have been defined.

 */

TInt TASSrvAlarm::SetStatus(TAlarmStatus aStatus)

	{

	return doSetStatus(aStatus, EFalse);

	}

/**

Change the state of this alarm.

*/

void TASSrvAlarm::SetState(TAlarmState aState)

	{

	const TAlarmState oldState = State();

	// Only process a change in state.

	if (oldState == aState)

		{

		return;

		}

	// Update current state.

	iState = aState;

	// If a paused alarm has re-notified (after the pause period is up) or has

	// been dismissed then clear the paused flag.

	if (HasSoundPaused() || iState == EAlarmStateNotifying || iState == EAlarmStateNotified)

		{

		ClearSoundPausedFlag();

		}

	// Handle new state.

	switch(aState)

		{

	case EAlarmStateQueued:

	case EAlarmStateSnoozed:

	case EAlarmStateWaitingToNotify:

	case EAlarmStateInPreparation:

		break;

	case EAlarmStateNotified:

		{		

		// If the alarm does not repeat or it is a 24 hour alarm then we do

		// nothing.  Notified alarms are cleaned up by the queue when they are

		// more than 7 days old.

		if (RepeatDefinition() != EAlarmRepeatDefintionRepeatOnce && RepeatDefinition() != EAlarmRepeatDefintionRepeatNext24Hours)

			{

			// Work out when the alarm should next repeat.

			PrepareForNextRepeat();

			}

		}

		break;

	case EAlarmStateNotifying:

		{

		TTime now(ASSrvStaticUtils::UtcTimeNow());

		ReinitializeSoundState(now);

		}

		break;

	default:

		{

		__ASSERT_DEBUG(EFalse, ASSrvStaticUtils::Fault(ASSrvStaticUtils::EASSrvFaultAlarmStateNotHandled));

		}

		break;

		}

	// Notify queue so that it can work out if it needs to do some reordering.

	// Only do this if this alarm has been queued (which we can infer if this

	// alarm has a non-null identifier).

	if (Id() != KNullAlarmId)

		{

		ServerData().Queue().HandleAlarmStateChanged(Id(), oldState);

		}

	// We call ourselves recursively if we are a repeating alarm.  We must do

	// this *after* the above HandleAlarmStateChanged() call because there must

	// be two state change notifictions otherwise observers will not behave

	// correctly...

	switch (RepeatDefinition())

		{

	case EAlarmRepeatDefintionRepeatOnce:

	case EAlarmRepeatDefintionRepeatNext24Hours:

		break;

	case EAlarmRepeatDefintionRepeatDaily:

	case EAlarmRepeatDefintionRepeatWorkday:

	case EAlarmRepeatDefintionRepeatWeekly:

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS

	case EAlarmRepeatDefinitionRepeatDailyOnGivenDays:

#endif

		if (oldState == EAlarmStateNotifying)

			{

			// Make sure we keep the snoozed state and not change to queued as

			// in the non-repeating alarms.

			if (aState == EAlarmStateSnoozed)

				{

				if (Id() != KNullAlarmId)

					{

					ServerData().Queue().HandleAlarmStateChanged(Id(), aState);						

					}

				}

			else

				{

				SetState(EAlarmStateQueued);					

				}

			}

		break;

	default:

		break;

		}

	}

//*************************************************************************************

/**

 * Change the characteristics of this alarm

 */

void TASSrvAlarm::SetCharacteristicsL(TAlarmCharacteristicsFlags aFlags, TASSrvSessionId aSessionChangingFlags)

	{

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	// if it is a wakeup alarm and they are trying to set session specific then leave

	if (aFlags.IsSet(EAlarmCharacteristicsSessionSpecific) && IsWakeup())

		{

		User::Leave(KErrArgument);		

		}

#endif

	const TAlarmCharacteristicsFlags oldCharacteristics = Characteristics();

	if	(oldCharacteristics.Value() == aFlags.Value())

		return;

	// If it was session-specific, but it isn't anymore, then we need

	// to complete the pending notification with KErrCancel

	if	(oldCharacteristics.IsSet(EAlarmCharacteristicsSessionSpecific) &&

		 !aFlags.IsSet(EAlarmCharacteristicsSessionSpecific))

		{

		// If there was a notification request then we complete it

		NotificationMessageComplete(KErrCancel);

		// Indicate that this alarm is no longer owned by a session

		iFlags.Set(EASShdAlarmFlagsHasBecomeOrphaned);

		}

	else if (!oldCharacteristics.IsSet(EAlarmCharacteristicsSessionSpecific) &&

		aFlags.IsSet(EAlarmCharacteristicsSessionSpecific))

		{

		// The session indicated wishes to take ownership of this alarm (but

		// can't request a expiry notification because these can only be setup

		// when an alarm is first created).

		SetOriginatingSessionId(aSessionChangingFlags);

		// Indicate that this alarm is now owned by a session

		iFlags.Clear(EASShdAlarmFlagsHasBecomeOrphaned);

		}

	// Update state now

	iCharacteristics = aFlags;

	// Notify queue so that it can work out if it needs to do

	// some re-ordering (only do this if we've been queued, and therefore

	// have an alarm id).

	if	(Id() != KNullAlarmId)

		ServerData().Queue().HandleAlarmCharacteristicsChanged(Id(), oldCharacteristics);

	}

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

void TASSrvAlarm::SetWakeupAndNotifyQueueL(TBool aEnable)

	{

	if (IsWakeup() == aEnable)

		{

		return;

		}

	if (aEnable && iCharacteristics.IsSet(EAlarmCharacteristicsSessionSpecific))

		{

		// you cannot set a session alarm as wakeup

		User::Leave(KErrArgument);		

		}

	SetWakeup(aEnable);

	if (Id() != KNullAlarmId)

		{

		ServerData().Queue().HandleWakeupChanged(Id());

		}

	}

#endif

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS

void TASSrvAlarm::SetAlarmDaysL(TUint8 aAlarmDays)

	{

	// Check if any modification to current alarms days is required.

	if (aAlarmDays == AlarmDays())

		{

		return;

		}

	User::LeaveIfError(SetAlarmDays(aAlarmDays));

	User::LeaveIfError(ASSrvStaticUtils::ValidateAlarm(*this));

	// Notify queue so that it can work out if it needs to do some reordering.

	ServerData().Queue().HandleAlarmDaysChanged(Id());

	}

#endif

void TASSrvAlarm::SetAlarmOrphaned()

	{

	iFlags.Set(EASShdAlarmFlagsHasBecomeOrphaned);

	}

//*************************************************************************************

/**

 * Set the originating session id for this alarm. The originating session Id is the

 * session Id (a unique id allocated to each session) which is used to track

 * all "session alarms" within the server.

 */

void TASSrvAlarm::SetOriginatingSessionId(TASSrvSessionId aId)

	{

	iOriginatingSessionId = aId;

	if	(aId >= 0)

		{

		iFlags.Set(EASShdAlarmFlagsHasOwningSession);

		}

	else

		{

		iFlags.Clear(EASShdAlarmFlagsHasOwningSession);

		}

	}

//

//

//

/**

Return the originating session id.

@return The id of the session that created the TASSrvAlarm.

*/

TASSrvSessionId TASSrvAlarm::OriginatingSessionId() const

	{

	return iOriginatingSessionId;

	}

/**

Return the alarm's sound state.

@return The state of the alarm's sound.

*/

TASSrvAlarm::TSoundState TASSrvAlarm::SoundState() const

	{

	return iSoundState;

	}

//

//

//

//*************************************************************************************

/**

 * Issue a request for notifications when this alarm expires

 */

void TASSrvAlarm::RequestExpiryNotificationL(const RMessage2& aMessage)

	{

	// Queue for notifications. This allows us to observe when the alarm expires

	// and notify the client

	ServerData().Timer().NotifyAlarmExpiredL(*this);

	// Save a pointer

	iNotificationMessage = aMessage;

	// Update flags to indicate we have a pending notification message pointer

	iInternalServerFlags.Set(EInternalServerFlagsNotifyPending);

	}

//*************************************************************************************

/**

 * Cancel a previous expiry notification request

 */

void TASSrvAlarm::RequestExpiryNotificationComplete(TInt aErrorCode)

 	{

	NotificationMessageComplete(aErrorCode);	

 	}

/**

Return whether or not the alarm has a notification request pending.

@return A TBool that is ETrue if the alarm has a notification request pending.

*/

TBool TASSrvAlarm::HasNotificationRequestPending() const

	{

	return iInternalServerFlags.IsSet(EInternalServerFlagsNotifyPending) && HasOwningSession();

	}

//*************************************************************************************

/**

 * Map the specified time object (data member) to the nearest minute (rounding down)

 */

void TASSrvAlarm::RoundDownTimeToMinute(TTimeType aType)

	{

	switch(aType)

		{

	case ETimeTypeNextDue:

		ASSrvStaticUtils::RoundTimeDownToTheMinute(iNextDueTime);

		break;

	case ETimeTypeOriginalExpiry:

		ASSrvStaticUtils::RoundTimeDownToTheMinute(iOriginalExpiryTime);

		break;

		}

	}

//*************************************************************************************

/**

 * Destroy this alarm. Removes it from the queue and marks it as inactive.

 */

void TASSrvAlarm::DeQueue()

	{

	ServerData().Queue().DeQueueAlarm(*this);

	}

//*************************************************************************************

/**

 * Reset this alarm back to a completely uninitialized state.

 */

void TASSrvAlarm::Reset()

	{

	TASShdAlarm::Reset();

	//

	iInternalServerFlags = 0;

	iOriginatingSessionId = 0;

	iSoundPeriodCycleNumber = 0;

	}

/**

Clears the alarm's flags.

*/

void TASSrvAlarm::ClearFlags()

	{

	iFlags = 0;

	}

/**

Set the alarm's sound state.

@param aSoundState The new TSoundState of this alarm.

*/

void TASSrvAlarm::SetSoundState(TSoundState aSoundState)

	{

	iSoundState = aSoundState;

	}

//*************************************************************************************

/**

 * Toggle the sound state of this alarm

 */

void TASSrvAlarm::ToggleSoundState()

	{

	// Invert the existing sound state

	if	(iSoundState == ESoundStatePlayingNothing)

		iSoundState = ESoundStatePlayingSound;

	else

		iSoundState = ESoundStatePlayingNothing;

	}

//*************************************************************************************

/**

 * If sound is temporarily silenced, then this method is used to re-initialize

 * the alarm's starting time for any future sound calculations.

 */

void TASSrvAlarm::ReinitializeSoundState(const TTime& aBaselineForSoundTiming)

	{

	// Reset the cycle and sound state ready to start playing

	ASSrvStaticUtils::TodayAtTheSpecifiedTime(aBaselineForSoundTiming, iStartTimeForSoundCalculations);

	SetSoundState(TASSrvAlarm::ESoundStatePlayingNothing);

	SetSoundTimingCycleIndex(0);

	}

//*************************************************************************************

/**

 * Work out when the alarm sound should next start or stop playing.

 */

TTime TASSrvAlarm::CalculateAndPrepareNextSoundCycle()

	{

	// If the new state is not to play any sound, and we've already progressed

	// through all the Sound Intervals, the SoundTimingCycleIndex will have

	// been set to KErrNotFound (see below)

	if ((SoundState() == ESoundStatePlayingNothing) &&

		(SoundTimingCycleIndex() == KErrNotFound)

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS

		|| Continuous()

#endif

		)

		{

		SetSoundTimingCycleIndex(0); // just to be safe, we'll reset this.

		return Time::NullTTime();

		}

	const CASSrvSoundSettings& soundSettings = ServerData().SoundSettings();

	// If the new state is not to play any sound, then we should work out when 

	// we should start playing sound again. If we're now about to start playing sound

	// we should work out when we're going to stop playing it again.

	CASSrvSoundSettings::TSoundCyclePosition position = CASSrvSoundSettings::ESoundCyclePositionAtStart;

	if (SoundState() == ESoundStatePlayingSound)

		{

		position = CASSrvSoundSettings::ESoundCyclePositionAtEnd;

		}

	//

#ifdef __DEBUGGING_TIMES

	TDateTime startTimeForSoundCalculations = iStartTimeForSoundCalculations.DateTime();

#endif

	ASSrvStaticUtils::TodayAtTheSpecifiedTime(iStartTimeForSoundCalculations, iStartTimeForSoundCalculations);

#ifdef __DEBUGGING_TIMES

	startTimeForSoundCalculations = iStartTimeForSoundCalculations.DateTime();

#endif

	TTime returnTime(soundSettings.SoundIntervalTime(iStartTimeForSoundCalculations, SoundTimingCycleIndex(), position));

#ifdef __DEBUGGING_TIMES

	TDateTime returnTimeDT = returnTime.DateTime();

#endif

	// Increment position at the end of the cycle

	if (SoundState() == ESoundStatePlayingSound)

		{

		// There will always be at least one sound play interval, so we can 

		// assume that here. If there hadn't been any intervals, the CASSrvSoundController

		// would be considered disabled, and wouldn't have invoked the current method.