// 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 <asshdalarm.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include "ASShdAlarm_internal.h"
#endif

// NOTE: Remember to change this version whenever the data format changes!
const TUint16 KAlarmExternalizedVersion = 2;
#ifndef SYMBIAN_SYSTEM_STATE_MANAGEMENT
const TUint16 KAlarmExternalizedSkipCount = 0; // Number of bytes to be skipped in data stream
#endif

/**
Default constructor. 

Initializes all member data to default values.
*/
EXPORT_C TASShdAlarm::TASShdAlarm()
	{
	Reset();
	}

/**
Internalizes the alarm's data from a read stream.

@param aStream The stream to read from.
*/
EXPORT_C void TASShdAlarm::InternalizeL(RReadStream& aStream)
	{
	// Read and ignore version (until its needed)
	aStream.ReadUint16L();
	iFlags.SetValue(aStream.ReadInt8L());
	// Session no longer valid!
	iFlags.Clear(EASShdAlarmFlagsHasOwningSession);
	iCharacteristics.SetValue(aStream.ReadInt8L());
	// Session alarms should be imported as orphaned
	// because there is no valid TRequestStatus to notify
	if (iCharacteristics.IsSet(EAlarmCharacteristicsSessionSpecific))
		{
		iCharacteristics.Clear(EAlarmCharacteristicsSessionSpecific);
		iFlags.Set(EASShdAlarmFlagsHasBecomeOrphaned);
		}
	iAlarmId = aStream.ReadInt32L();
	iStatus = static_cast<TAlarmStatus>(aStream.ReadInt8L());
	iState = static_cast<TAlarmState>(aStream.ReadInt8L());
	iDayOrTimed = static_cast<TAlarmDayOrTimed>(aStream.ReadInt8L());
	iRepeatDefinition = static_cast<TAlarmRepeatDefinition>(aStream.ReadInt8L());
	aStream >> iCategory;
	TInt64 tempInt64;
	aStream >> tempInt64;
	iNextDueTime = TTime(tempInt64);
	aStream >> tempInt64;
	iOriginalExpiryTime = TTime(tempInt64);
	aStream >> iMessage;
	aStream >> iSoundName;
	iClientFlags.SetValue(aStream.ReadInt16L());
	iClientData1 = aStream.ReadInt32L();
	iClientData2 = aStream.ReadInt32L();
	//Only read the SID in the secured platform
	iTASShdAlarmSID = aStream.ReadUint32L();
#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
	iFlags2.SetValue(aStream.ReadInt16L());
#else
	// Read and ignore the skip count until its needed. When new data is written
	// to the end of the alarm, be sure to use the version information as a means
	// of establishing exactly how much data can be read. This enables the alarm
	// server to remain data compatible going forwards...
	aStream.ReadUint16L();
#endif
	}

/**
Externalizes the alarm's member data to a write stream.

@param aStream The stream to write to.
*/
EXPORT_C void TASShdAlarm::ExternalizeL(RWriteStream& aStream) const
	{
	// Write version
	aStream.WriteUint16L(KAlarmExternalizedVersion);
	aStream.WriteInt8L(iFlags.Value());
	aStream.WriteInt8L(iCharacteristics.Value());
	aStream.WriteInt32L(iAlarmId);
	aStream.WriteInt8L(static_cast<TInt8>(iStatus));
	aStream.WriteInt8L(static_cast<TInt8>(iState));
	aStream.WriteInt8L(static_cast<TInt8>(iDayOrTimed));
	aStream.WriteInt8L(static_cast<TInt8>(iRepeatDefinition));
	aStream << iCategory;
	aStream << iNextDueTime.Int64();
	aStream << iOriginalExpiryTime.Int64();
	aStream << iMessage;
	aStream << iSoundName;
	aStream.WriteInt16L(iClientFlags.Value());
	aStream.WriteInt32L(iClientData1);
	aStream.WriteInt32L(iClientData2);
	//Only store the SID in the secured platform
	aStream.WriteUint32L(iTASShdAlarmSID);
#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
	aStream.WriteInt16L(iFlags2.Value());
#else
	// Write skip count
	aStream.WriteUint16L(KAlarmExternalizedSkipCount);
#endif
	}

/**
Resets the alarm back to a default, uninitialized state.
*/
EXPORT_C void TASShdAlarm::Reset()
	{
	iFlags = 0,
	iCharacteristics = 0;
	iAlarmId = KNullAlarmId;
	iStatus = EAlarmStatusDisabled;
	iState = EAlarmStateInPreparation;
	iDayOrTimed = EASShdAlarmTypeTimed;
	iRepeatDefinition = EAlarmRepeatDefintionRepeatOnce;
	iCategory = KNullUid;
	iNextDueTime = Time::NullTTime();
	iOriginalExpiryTime = Time::NullTTime();
	iMessage = KNullDesC;
	iSoundName = KNullDesC;
	iClientFlags.ClearAll();
	iClientData1 = 0;
	iClientData2 = 0;
#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
	iFlags2 = 0;
#endif
#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS
	iFlags2 = 0;
	// By default, an alarm with a repeat definition of EAlarmRepeatDefinition-
	// DailyOnGivenDays is active on all days.
	SetAlarmDays(EAlarmDayMonday | EAlarmDayTuesday | EAlarmDayWednesday |
		EAlarmDayThursday | EAlarmDayFriday | EAlarmDaySaturday |
		EAlarmDaySunday);
#endif
	}	

/**
Using this API to set the next due time of an alarm will make it a fixed alarm, that
is going to expire at the given UTC time. The alarm will not be rescheduled when the UTC offset is changed.

@param aUtcTime The due time of the alarm should be given in UTC.
*/
EXPORT_C void TASShdAlarm::SetUtcNextDueTime(TTime aUtcTime)
	{
	iNextDueTime = aUtcTime;
	iCharacteristics.Set(EAlarmCharacteristicsIsFixed);	
	}

/**
Using this API to tell the alarmserver not to notify the Agenda alarms if
its due time is in the past after system time has been changed.
*/
EXPORT_C void TASShdAlarm::SetDeQueueIfDueTimeInPast()
	{
	iCharacteristics.Set(EAlarmCharacteristicsDeQueueIfDueTimeInPast);	
	}

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
EXPORT_C void TASShdAlarm::SetWakeup(TBool aEnabled)
	{
	if (aEnabled)
		{
		iFlags2.Set(EASShdAlarmFlag2Wakeup);
		}
	else
		{
		iFlags2.Clear(EASShdAlarmFlag2Wakeup);
		}
	}

EXPORT_C TBool TASShdAlarm::IsWakeup() const
	{
	return iFlags2.IsSet(EASShdAlarmFlag2Wakeup);
	}
#endif

#ifdef SYMBIAN_ALARM_REPEAT_EXTENSIONS
/**
Sets which days of the week an alarm with a repeat definition of
EAlarmRepeatDefintionRepeatDailyOnGivenDays activates on.  By default, an alarm
with a repeat definition of EAlarmRepeatDefinitionRepeatDailyOnGivenDays will be
active on all days of the week.

@prototype

@param aAlarmDays
	The days of the week that the alarm activates on.  Days are combined using
	the bitwise OR operator e.g. EAlarmDayMonday|EAlarmDayTuesday.

@return
	KErrNone if successful, KErrArgument if aAlarmDays is an invalid value.
*/
EXPORT_C TInt TASShdAlarm::SetAlarmDays(TUint8 aAlarmDays)
	{
	TUint8 alarmDaysMask = ~(EAlarmDayMonday | EAlarmDayTuesday |
		EAlarmDayWednesday | EAlarmDayThursday | EAlarmDayFriday |
		EAlarmDaySaturday | EAlarmDaySunday);
	
	if ((aAlarmDays == 0) || ((aAlarmDays & alarmDaysMask) != 0))
		{
		return KErrArgument;
		}
		
	iFlags2.Assign(EASShdAlarmFlag2AlarmDayMonday,
		aAlarmDays & EAlarmDayMonday);

	iFlags2.Assign(EASShdAlarmFlag2AlarmDayTuesday,
		aAlarmDays & EAlarmDayTuesday);
	
	iFlags2.Assign(EASShdAlarmFlag2AlarmDayWednesday,
		aAlarmDays & EAlarmDayWednesday);

	iFlags2.Assign(EASShdAlarmFlag2AlarmDayThursday,
		aAlarmDays & EAlarmDayThursday);

	iFlags2.Assign(EASShdAlarmFlag2AlarmDayFriday,
		aAlarmDays & EAlarmDayFriday);

	iFlags2.Assign(EASShdAlarmFlag2AlarmDaySaturday,
		aAlarmDays & EAlarmDaySaturday);

	iFlags2.Assign(EASShdAlarmFlag2AlarmDaySunday,
		aAlarmDays & EAlarmDaySunday);

	return KErrNone;
	}

/**
Returns the days of the week that the alarm activates on.  This value is only
applicable if the alarm’s repeat definition is
EAlarmRepeatDefinitionRepeatDailyOnGivenDays.  By default, an alarm with a
repeat definition of EAlarmRepeatDefinitionRepeatDailyOn-GivenDays will be
active on all days of the week.

@prototype

@return
	The days of the week the alarm activates on.
*/
EXPORT_C TUint8 TASShdAlarm::AlarmDays() const
	{
	TUint8 alarmDays = 0;
	
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDayMonday))
		{
		alarmDays |= EAlarmDayMonday;
		}
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDayTuesday))
		{
		alarmDays |= EAlarmDayTuesday;
		}
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDayWednesday))
		{
		alarmDays |= EAlarmDayWednesday;
		}
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDayThursday))
		{
		alarmDays |= EAlarmDayThursday;
		}
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDayFriday))
		{
		alarmDays |= EAlarmDayFriday;
		}
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDaySaturday))
		{
		alarmDays |= EAlarmDaySaturday;
		}
	if (iFlags2.IsSet(EASShdAlarmFlag2AlarmDaySunday))
		{
		alarmDays |= EAlarmDaySunday;
		}
	
	return alarmDays;
	}

/**
Sets whether or not the alarm is continuous.

@prototype

@param aContinuous
	ETrue if the alarm is continuous, EFalse if the alarm is not continuous.
*/
EXPORT_C void TASShdAlarm::SetContinuous(TBool aContinuous)
	{
	iFlags2.Assign(EASShdAlarmFlag2Continuous, aContinuous);
	}

/**
Returns the continuous state for the alarm.

@prototype

@return
	ETrue if the alarm is continuous, EFalse if the alarm is not continuous.
*/
EXPORT_C TBool TASShdAlarm::Continuous()
	{
	return iFlags2.IsSet(EASShdAlarmFlag2Continuous);
	}

#endif
	

/** Tests whether the alarm has any associated data. 
	
@return True if the alarm has associated data. */
EXPORT_C TBool TASShdAlarm::HasAssociatedData() const

	{
	return iFlags.IsSet(EASShdAlarmFlagsHasAssociatedData);
	}


/** Tests whether the alarm has an active owning session.

@return True if the alarm has an active owning session. */
EXPORT_C TBool TASShdAlarm::HasOwningSession() const

	{
	return iFlags.IsSet(EASShdAlarmFlagsHasOwningSession);
	}

EXPORT_C TBool TASShdAlarm::HasBecomeOrphaned() const
/** Tests whether the alarm is orphaned. 

An alarm is ophaned if it used to have an owning session, but no longer does. 
If an alarm is owned by a session, it is removed from the queue when the session 
disconnects. However, orphaned alarms stay in the queue.
	
@return True if the alarm has becomed orphaned. */
	{
	return iFlags.IsSet(EASShdAlarmFlagsHasBecomeOrphaned);
	}