// 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 <asclisession.h>

// System includes

#include <s32mem.h>

// User includes

#include <asshdalarm.h>

#include "ASShdPragma.h"

#include "ASShdOpCodes.h"

//

#include <asclisoundplay.h>

#include <ascliclientutils.h>

#include <asclidefinitions.h>

// Type definitions

// Constants

const TInt KNumberOfServerStartupAttempts = 2;

// Enumerations

//

// ----> RASCliSession (source)

//

/**

Default constructor.

Creates an instance of the RASCliSession class, setting its pointers to null.

*/

EXPORT_C RASCliSession::RASCliSession()

:	iPackage(NULL, 0, 0), iAlarmIdPointer(NULL, 0, 0)

	{

	}

/**

Connects the client process to the alarm server, starting the server if it 

is not already running.

@capability None

@return KErrNone if successful, otherwise one of the system-wide errors.

*/

EXPORT_C TInt RASCliSession::Connect()

	{

	TInt startupAttempts = KNumberOfServerStartupAttempts;

	for(;;)

		{

		TInt ret = CreateSession(ASCliDefinitions::ServerAndThreadName(), ASCliDefinitions::Version(), KAlarmServerAsynchronousSlotCount);

		if	(ret != KErrNotFound && ret != KErrServerTerminated)

			{

			return ret;

			}

		if	(startupAttempts-- == 0)

			{

			return ret;

			}

		ret = AlarmClientUtils::StartAlarmServer();

		if	(ret != KErrNone && ret != KErrAlreadyExists)

			{

			return ret;

			}

		}

	}

/** Provides the version number of the alarm server.

@capability None

@return The version number. */

EXPORT_C TVersion RASCliSession::Version() const

	{

	return ASCliDefinitions::Version();

	}

//

//

//

/** Validates an alarm object, allocates an unique identifier to it, and adds the 

object synchronously to the alarm server's queue.

@capability WriteUserData 

@param aAlarm The alarm object to add. On return, contains a unique identifier 

that the client can use to identify the alarm.

@return KErrNone if successful, otherwise one of the system-wide error codes. */

EXPORT_C TInt RASCliSession::AlarmAdd(TASShdAlarm& aAlarm) const

	{

	return DoAlarmAdd(aAlarm, KNullDesC8);

	}

/**

@capability WriteUserData 

*/

TInt RASCliSession::DoAlarmAdd(TASShdAlarm& aAlarm, const TDesC8& aData) const

	{

	TPckg<TASShdAlarm> package(aAlarm);

	TIpcArgs args(&package, aData.Length(), &aData);

	// Send message to server.

	return SendReceive(EASShdOpCodeAlarmAdd, args);

	}

/** Validates an alarm object, allocates an unique identifier to it, and adds the 

object with data synchronously to the alarm server's queue.

@capability WriteUserData 

@param aAlarm The alarm object to add. On return, contains a unique identifier 

that the client can use to identify the alarm.

@param aData Client-specific data to associate with the alarm. 

@return KErrNone if successful, otherwise one of the system-wide error codes.*/

EXPORT_C TInt RASCliSession::AlarmAdd(TASShdAlarm& aAlarm, const TDesC8& aData) const

	{

	return DoAlarmAdd(aAlarm, aData);

	}

/** Makes an asynchronous request to add an alarm object to the alarm server's 

queue.

It also allocates a unique identifier of type TAlarmId to the alarm object and 

adds the alarm object to the alarm server's queue.

When the alarm expires, or is cancelled, the alarm server notifies the client 

by completing the outstanding request.

@capability WriteUserData 

@param aStatus On completion of the request, this object holds the completion 

code.

@param aAlarm The alarm to add. On return, contains the unique identifier. KNullAlarmId indicates failure.*/

EXPORT_C void RASCliSession::AlarmAddWithNotification(TRequestStatus& aStatus, TASShdAlarm& aAlarm)

	{

	DoAlarmAddWithNotification(aStatus, aAlarm, KNullDesC8);

	}

/**

@capability WriteUserData

*/	

void RASCliSession::DoAlarmAddWithNotification(TRequestStatus& aStatus, TASShdAlarm& aAlarm, const TDesC8& aData)

	{

	// Set the session specific flag

	aAlarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific);

	// add the alarm and wait for notification. 

	TIpcArgs args(&iPackage, aData.Length(), &aData);

	//

	iPackage.Set((TUint8*) &aAlarm, sizeof(TASShdAlarm), sizeof(TASShdAlarm));

	// Unfortunately there is no way to send a request flag synchronously

	// The basic idea behind the asynchronous sendReceive is that we can attach a 

	// status flag to get informed whenever the server has accomplished the given task,

	// specifyed by the OpCode. However, in this case the flag  is used when an alarm

	// expires and not when the alarm server is ready registrating the alarm.

	// Therefore, we have to make a synchronous call afterwards to synchronise the client and server

	aAlarm.Id() = KNullAlarmId;

	SendReceive(EASShdOpCodeAlarmAddWithNotification, args, aStatus);

	// The synchronous call to synchronise the client and server.

	SendReceive(EASShdOpCodeFlushServer);

	}

/** 

Makes an asynchronous request to add an alarm object 

with the agenda entry information attached to the alarm server's 

queue.

It also allocates a unique identifier of type TAlarmId to the alarm object and 

adds the alarm object to the alarm server's queue.

When the alarm expires, or is cancelled, the alarm server notifies the client 

by completing the outstanding request.

@capability WriteUserData 

@param aStatus On completion of the request, this object holds the completion 

code.

@param aAlarm The alarm to add. On return, contains the unique identifier. KNullAlarmId indicates failure.

@param aData Client-specific data to associate with the alarm.

*/

EXPORT_C void RASCliSession::AlarmAddWithNotification(TRequestStatus& aStatus, TASShdAlarm& aAlarm, const TDesC8& aData)

	{

	DoAlarmAddWithNotification(aStatus, aAlarm, aData);

	}

/** Cancels an outstanding notification for an alarm and removes it from the queue.

@capability Note If the user does not have WriteDeviceData capability then we need to check

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarmId The unique identifier of the alarm to be cancelled. */

EXPORT_C void RASCliSession::AlarmNotificationCancelAndDequeue(TAlarmId aAlarmId) const

	{

	TIpcArgs args(aAlarmId);

	// Backup/Restore locking the file or the Server dying are not programming

	// errors - any other error panics the client. 	

	const TInt error = SendReceive(EASShdOpCodeAlarmNotificationCancelAndDeQueue, args);

	__ASSERT_ALWAYS(error == KErrNone || error == KErrServerTerminated || error == KErrLocked, AlarmClientUtils::Panic(AlarmClientUtils::EAlarmClientPanicNotificationCancel));

	}

/** Retrieves information about a specified alarm.

@capability Note If the user does not have ReadUserData capability then we need to check 

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarmId The unique identifier of the alarm under query.

@param aAlarm On return, contains details of the alarm sought.

@return KErrNone if successful, KErrCouldNotConnect if the time zone server is

not available, otherwise one of the other system-wide error codes. */

EXPORT_C TInt RASCliSession::GetAlarmDetails(TAlarmId aAlarmId, TASShdAlarm& aAlarm) const

	{

	TPckg<TASShdAlarm> package(aAlarm);

	TIpcArgs args(aAlarmId,&package);

	return SendReceive(EASShdOpCodeGetAlarmDetails, args);

	}

/** Deletes an alarm from the alarm server.

@capability Note If the user does not have WriteDeviceData capability then we need to check 

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarmId The unique identifier of the alarm to be deleted.

@return KErrNone if successful, KErrNotFound if the specified alarm does not 

exist, KErrAccessDenied if the alarm has an outstanding notification, or else 

one of the system-wide error codes. */

EXPORT_C TInt RASCliSession::AlarmDelete(TAlarmId aAlarmId) const

	{

	TIpcArgs args(aAlarmId);

	return SendReceive(EASShdOpCodeAlarmDelete, args);

	}

/** Retrieves the category of an alarm. 

@capability None

@param aAlarmId The unique identifier of the alarm under query.

@param aCategory On return, contains the category of the alarm.

@return KErrNone if successful, KErrNotFound if the alarm does not exist, otherwise 

one of the system-wide error codes. */

EXPORT_C TInt RASCliSession::GetAlarmCategory(TAlarmId aAlarmId, TAlarmCategory& aCategory) const

	{

	TPckg<TAlarmCategory> package(aCategory);

	TIpcArgs args(aAlarmId, &package);

	//

	return SendReceive(EASShdOpCodeGetAlarmCategory, args);

	}

/** @deprecated 8.0

Retrieves the full name of the thread that owns the specified alarm.

@capability None

@param aAlarmId The unique identifier of the alarm under query.

@param aThreadName On return, contains the name of the owning session.

@return KErrNone if successful, KErrNotFound if the alarm has no originating 

session ID or if the session is no longer connected, otherwise one of the 

system-wide errors. */

EXPORT_C TInt RASCliSession::GetAlarmOwner(TAlarmId aAlarmId, TFullName& aThreadName) const

	{

//

// From 8.0 onwards, this function returns a NULL string.

// See CASSrvSession::MASSrvSessionFullName

//

	TIpcArgs args(aAlarmId, &aThreadName);

	return SendReceive(EASShdOpCodeGetAlarmOwner, args);

	}

/** Sets an alarm's status to either enabled or disabled.

@capability Note If the user does not have WriteDeviceData capability then we need to check 

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarmId Unique identifier of the alarm.

@param aStatus Contains the status to be applied. 

@return KErrNone if successful, otherwise one of the system-wide error codes. */

EXPORT_C TInt RASCliSession::SetAlarmStatus(TAlarmId aAlarmId, TAlarmStatus aStatus) const

	{

	TIpcArgs args(aAlarmId, aStatus);

	return SendReceive(EASShdOpCodeSetAlarmStatus, args);

	}

/** Sets the alarm status for calendar file

@param aFileName Calendar file name 

@param aStatus Contains the status to be applied.  

@return KErrNone if successful, otherwise one of the system-wide error codes. */

EXPORT_C TInt RASCliSession::SetAlarmStatusForCalendarFile(const TDesC& aFileName, TAlarmStatus aStatus) const

    {

    TIpcArgs args(&aFileName, aStatus);

    return SendReceive(EASShdOpCodeSetAlarmStatusForCalendarFile, args);

    }

/** Retrieves the status of the alarm. 

@capability None

@param aAlarmId The unique identifier of an alarm under query.

@param aStatus On return, the alarm status.

@return KErrNone if successful, KErrNotFound if the alarm does not exist, otherwise 

one of the system-wide errors. */

EXPORT_C TInt RASCliSession::GetAlarmStatus(TAlarmId aAlarmId, TAlarmStatus& aStatus) const

	{

	TPckg<TAlarmStatus> package(aStatus);

	TIpcArgs args(aAlarmId, &package);

	//

	return SendReceive(EASShdOpCodeGetAlarmStatus, args);

	}

/** Specifies whether an alarm belongs to a timed or untimed event.

@capability Note If the user does not have WriteDeviceData capability then we need to check 

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarmId Unique identifier of the alarm.

@param aDayOrTimed Whether an alarm is for a timed or untimed event. 

@return KErrNone if successful, otherwise one of the system-wide errors. */

EXPORT_C TInt RASCliSession::SetAlarmDayOrTimed(TAlarmId aAlarmId, TAlarmDayOrTimed aDayOrTimed) const

	{

	TIpcArgs args(aAlarmId, aDayOrTimed);

	return SendReceive(EASShdOpCodeSetAlarmDayOrTimed, args);

	}

/** Tests whether the specified alarm is for a timed or untimed event.

@capability None

@param aAlarmId Unique identifier of the alarm under query.

@param aDayOrTimed On return, whether an alarm is for a timed or untimed event.

@return KErrNone if successful, otherwise one of the system-wide errors. */

EXPORT_C TInt RASCliSession::GetAlarmDayOrTimed(TAlarmId aAlarmId, TAlarmDayOrTimed& aDayOrTimed) const

	{

	TPckg<TAlarmDayOrTimed> package(aDayOrTimed);

	TIpcArgs args(aAlarmId, &package);

	//

	return SendReceive(EASShdOpCodeGetAlarmDayOrTimed, args);

	}

/** Sets the characteristics of a specified alarm. 

If the session-specific flag is removed, the outstanding notification 

is completed.

@capability Note If the user does not have WriteDeviceData capability then we need to check 

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarmId Unique identifier of the alarm. 

@param aCharacteristics Alarm characteristics to apply. 

@return KErrNone if successful, otherwise one of the system-wide errors. */

EXPORT_C TInt RASCliSession::SetAlarmCharacteristics(TAlarmId aAlarmId, TAlarmCharacteristicsFlags aCharacteristics) const

	{

	TPckgC<TAlarmCharacteristicsFlags> package(aCharacteristics);

	TIpcArgs args(aAlarmId, &package);

	//

	return SendReceive(EASShdOpCodeSetAlarmCharacteristics, args);

	}

/** Gets the characteristics of an alarm.

@capability None

@param aAlarmId Unique identifier of the alarm under query.

@param aCharacteristics On return, contains the charcteristics of the alarm 

specified.

@return KErrNone if successful, otherwise one of the system-wide errors. */

EXPORT_C TInt RASCliSession::GetAlarmCharacteristics(TAlarmId aAlarmId, TAlarmCharacteristicsFlags& aCharacteristics) const

	{

	TPckg<TAlarmCharacteristicsFlags> package(aCharacteristics);

	TIpcArgs args(aAlarmId, &package);

	//

	return SendReceive(EASShdOpCodeGetAlarmCharacteristics, args);

	}

/** Sets if the alarm is a wakeup alarm

@capability None

@param aAlarmId Unique identifier of the alarm under query.

@param aEnabled if the alarm is to be a wakeup alarm.

@return KErrNone if successful, otherwise one of the system-wide errors. */

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

EXPORT_C TInt RASCliSession::SetWakeup(TAlarmId aAlarmId, TBool aEnabled) const

	{

	TIpcArgs args(aAlarmId, aEnabled);

	return SendReceive(EASShdOpCodeSetWakeup, args);

	}

#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

@capability

	WriteDeviceData

	Note: If the client does not have WriteDeviceData capability then it must

	own the alarm.  A client owns an alarm if the SID of the client matches the

	SID of the alarm.

@param aAlarmId

	Identifies the alarm whose alarm days are to be set.

@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

	otherwise one of the system-wide errors.

*/

EXPORT_C TInt RASCliSession::SetAlarmDays(TAlarmId aAlarmId, TUint8 aAlarmDays) const

	{

	TIpcArgs args(aAlarmId, aAlarmDays);

	return SendReceive(EASShdOpCodeSetAlarmDays, args);

	}

/**

Gets the days of the week that the given 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

@param aAlarmId

	Identifies the alarm whose alarm days are to be returned.

@param aAlarmDays

	On return the days of the week that the alarm activates on.  The value will

	be a combination of the values defined in the TAlarmDays enumeration.

@return

	KErrNone if successful, otherwise one of the system-wide errors.

*/

EXPORT_C TInt RASCliSession::GetAlarmDays(TAlarmId aAlarmId, TUint8& aAlarmDays) const

	{

	TPckg<TUint8> package(aAlarmDays);

	TIpcArgs args(aAlarmId, &package);

	return SendReceive(EASShdOpCodeGetAlarmDays, args);

	}

/**

Sets the continuous state of the given alarm. 

@prototype

@capability

	WriteDeviceData

	Note: If the client does not have WriteDeviceData capability then it must

	own the alarm.  A client owns an alarm if the SID of the client matches the

	SID of the alarm.

@param aAlarmId

	Identifies the alarm whose continuous state is to be set.

@param aContinuous

	ETrue if the alarm is continuous, EFalse if the alarm is not continuous.

@return

	KErrNone if successful, otherwise one of the system-wide errors.

*/

EXPORT_C TInt RASCliSession::SetContinuous(TAlarmId aAlarmId, TBool aContinuous) const

	{

	TIpcArgs args(aAlarmId, aContinuous);

	return SendReceive(EASShdOpCodeSetContinuous, args);

	}

/**

Gets the continuous state of the given alarm.

@prototype

@param aAlarmId

	Identifies the alarm whose continuous state is to be returned.

@param aContinuous

	On return ETrue if the alarm is continuous, EFalse if the alarm is not

	continuous.

@return

	KErrNone if successful, otherwise one of the system-wide errors.

*/

EXPORT_C TInt RASCliSession::GetContinuous(TAlarmId aAlarmId, TBool& aContinuous) const

	{

	TPckg<TBool> package(aContinuous);

	TIpcArgs args(aAlarmId, &package);

	return SendReceive(EASShdOpCodeGetContinuous, args);

	}

#endif

/** Updates an alarm's client-specific data in the alarm server.

The TASShdAlarm class contains a number of client-specific fields. These fields 

are for use by clients of the alarm server to hold any data associated with 

an alarm. Although this data is not used in any way by the alarm server itself, 

clients can ensure that the alarm server keeps its own copy of the specified 

alarm up to date with that of the client.

@capability Note If the user does not have WriteDeviceData capability then we need to check 

that the alarm belongs to the user SID (The SID is stored as part of the alarm)

@param aAlarm The client-side alarm, whose corresponding server-side alarm 

is to be updated.