// 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 "ConsoleAlarmAlertSession.h"

#include <e32svr.h>

#include <asaltdefs.h>

#include "ConsoleAlarmAlertSession.h"

#include "ConsoleAlarmAlertConsole.h"

#include "ConsoleAlarmAlertLEDFlasher.h"

#include "ConsoleAlarmAlertServer.h" //for inter-session communication

const TInt KSlot0 = 0;

const TInt KSlot1 = 1;

const TInt KSlot2 = 2;

// message -> string 

static const TDesC& function_to_string(TInt function);

CConsoleAlarmAlertSession::CConsoleAlarmAlertSession(CConsoleAlarmAlertServer* aServer)

:	iServer(aServer), iInstructionSet(NULL), iInstructionSetFound(EFalse)

	{

	}

CConsoleAlarmAlertSession::~CConsoleAlarmAlertSession()

	{

	CancelNotifications();

	__FLOG_CLOSE;

	CConsoleAlarmAlertSession* session = iServer->WaitingSession();

	session = NULL;

	delete iSoundLEDFlasher;

	delete iSoundCallbackTimer;

	delete iConsole;

	}

void CConsoleAlarmAlertSession::ConstructL()

	{

	iSoundLEDFlasher = CConsoleAlarmAlertLEDFlasher::NewL();

	iSoundCallbackTimer = CPeriodic::NewL(CActive::EPriorityIdle);

	iConsole = new(ELeave) CConsoleAlarmAlertConsole(*this);

	__FLOG_CONNECT;

	__FLOG_CREATE(KLogFile, RFileFlogger::ELogModeAppend);

	}

CConsoleAlarmAlertSession* CConsoleAlarmAlertSession::NewL(CConsoleAlarmAlertServer* aServer)

	{

	CConsoleAlarmAlertSession* self = new(ELeave) CConsoleAlarmAlertSession(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

TTime CConsoleAlarmAlertSession::DeferTime() const

	{

	return iDeferTime;

	}

void CConsoleAlarmAlertSession::Notify(TASAltAlertServerResponse aFlag)

	{

	if	(iHasMessage)

		{

		TPckgC<TAlarmId> pId(iAlarm.Id());

		TRAPD(err, iMsgPtr.WriteL(KSlot0, pId));

		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

		iMsgPtr.Complete(aFlag);

		iHasMessage = EFalse;

		}

	}

void CConsoleAlarmAlertSession::Notify(TASAltAlertServerResponse aFlag, const TTime& aDeferTime)

	{

	if	(iHasMessage)

		{	

		TPckgC<TTime> time(aDeferTime);

		TRAPD(err, iMsgPtr.WriteL(KSlot1, time));

		__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

		Notify(aFlag);

		}

	}

void CConsoleAlarmAlertSession::ServiceL(const RMessage2& aMessage)

	{

	_LIT(KMsgFmt, "CConsoleAlarmAlertSession::ServiceL: Message: %s (%i) (0x%x 0x%x 0x%x 0x%x)");

	__FLOG_INFO7(KMsgFmt, function_to_string(aMessage.Function()).Ptr(), aMessage.Function(), 

				aMessage.Int0(), aMessage.Int1(), aMessage.Int2(), aMessage.Int3());

	if (iServer->IsExtendedMode()) 

		{

		if (MultiDispatchL(aMessage)) 

			{

			aMessage.Complete(KErrNone);

			}

		return;

		}

	iMsgComplete = ETrue;

	const TInt function = aMessage.Function();

	//see if the server holds a set of instructions to be followed,

	//rather than waiting for user input.

	if(!iInstructionSetFound) //go look for it now.

		{

		//we will enter into this code only once

		const CServer2* tmpServ = Server();

		const CConsoleAlarmAlertServer* specific = reinterpret_cast<const CConsoleAlarmAlertServer*>(tmpServ);

		iInstructionSet = const_cast<CConsoleAlarmAlertServer*>(specific)->ResponseArray();

		iInstructionSetFound = ETrue;

		}

	//

	switch(function)

		{

	case EASAltTestOpCodeSetExtendedMode:

		iServer->SetExtendedMode(ETrue);

		iMsgComplete = ETrue;

		break;

	case EASAltOpCodeGetMaxAlarms:

		CmdGetMaxAlarmsL(aMessage);

		iMsgComplete = ETrue;

		break;

	case EASAltOpCodeDeleteAlarm:

	case EASAltOpCodeDeleteAlarmAll:

	case EASAltOpCodeVisibleAll:

	case EASAltOpCodeSetStateAll:

		iMsgComplete = ETrue;

		break;

    case EASAltOpCodeNotify:

    	{

		__ASSERT_ALWAYS(!iHasMessage, User::Invariant());

		iMsgComplete = EFalse;

		iMsgPtr = aMessage;

		iHasMessage = ETrue;

		iServer->SetWaitingSession(this);

		iServer->SetNotifyMessage(&iMsgPtr);

		break;

		}

    case EASAltOpCodeNotifyCancel:

		if	(iHasMessage)

			{

			iHasMessage=EFalse;

			iMsgPtr.Complete(KErrCancel);

			iServer->SetNotifyMessage(NULL);

			}

		break;

	case EASAltOpCodeVisible:

		{

		TBool isVisible = aMessage.Int0();

		iConsole->SetVisibilityL(isVisible);

		iServer->SetNotifying(isVisible);

		break;

		}

    case EASAltOpCodeSetState:

		iConsole->SetAlertStateL(aMessage.Int0());

		break;

    case EASAltOpCodeSetAlarm:

		SetAlarmL(aMessage);

		iConsole->iTimeInterval=0;

		iConsole->UpdateDisplayL();

		// Forces the Console to get response for the next alarm.

		iConsole->CancelKey();

		break;

	case EASAltOpCodeGetUserTime:

	case EASAltOpCodeGetEndQuietTime:

		GetUserTimeL(aMessage);

		break;

	case EASAltOpCodeSetDeferTime:

		SetDeferTimeL(aMessage);

		iConsole->UpdateDisplayL();

		break;

    case EASAltOpCodeLogon:

		__ASSERT_ALWAYS(!iLoggedOn, User::Invariant());

		iMsgComplete=EFalse;

		iLoggedOn=ETrue;

		break;

	case EASAltOpCodeStartPlayingSound:

		{

		iSoundLEDFlasher->Start();

		TCallBack callback(SoundPlaybackCallbackL, this);

		iSoundCallbackTimer->Start(TTimeIntervalMicroSeconds32(0), TTimeIntervalMicroSeconds32(3000000), callback);

		break;

		}

	case EASAltOpCodeStopPlayingSoundAll: // Fallthrough

	case EASAltOpCodeStopPlayingSound:

		iSoundLEDFlasher->Stop();

		iSoundCallbackTimer->Cancel();

		break;

//Test code

	case EASAltTestOpCodeAcknowledgeAlarm:

		if (iServer->WaitingSession())

			iServer->WaitingSession()->Notify(EASAltAlertServerResponseClear);

		break;

	case EASAltTestOpCodeGetAttachment:

		{

		if (iServer->Attachment() != NULL)

			{

			const TDes8& data = iServer->Attachment()->Des();

			const TInt maxLength = static_cast<TInt>(aMessage.Int0());

			if	(data.Size() > maxLength)

				User::Panic(_L("Client's buffer is too short"), KErrOverflow);

			else

				{

				if (data.Length() == 0)

					{

					_LIT8(KEmpty,"Empty");

					aMessage.WriteL(KSlot1, KEmpty);

					}

				else

					{

					aMessage.WriteL(KSlot1, data);

					}

				iServer->SetAttachment(NULL);

				}

			}

		}

		break;

	case EASAltTestOpCodeGetIsNotifying:

		{

		TPckgC<TBool> ret = iServer->IsNotifying();

		aMessage.WriteL(KSlot0, ret);

		break;

		}

	default:

		User::Invariant();

		break;

		}

	if	(iMsgComplete)

		aMessage.Complete(KErrNone);

	}

TBool CConsoleAlarmAlertSession::CmdL()

	{

	return KErrNone;

	}

void CConsoleAlarmAlertSession::ServiceError(const RMessage2 &aMessage, TInt aError)

	{

	_LIT(KErrFmt, "CConsoleAlarmAlertSession::ServiceError: Message: %s (0x%x, 0x%x, 0x%x, 0x%x) Error: %i");

	__FLOG_INFO7(KErrFmt, function_to_string(aMessage.Function()).Ptr(), 

				aMessage.Int0(), aMessage.Int1(), aMessage.Int2(), aMessage.Int3(),

				aError); 

	}

//

//

//

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

void CConsoleAlarmAlertSession::SetAlarmL(const RMessage2& aMessage)

	{

	TPckg<TASShdAlarm> pA(iAlarm);  

	aMessage.ReadL(KSlot0, pA);

	   	//These lines will make sure the alert server is given the alarm in local time, if the alarm is set in local time (a floating alarm)

  	if (iAlarm.IsFloating())  				

  		{						

  			TTimeIntervalSeconds offset = User::UTCOffset();

  			if (iAlarm.NextDueTime() != Time::NullTTime())

  			    {

  			    iAlarm.NextDueTime() += offset;

  			    }

  			if (iAlarm.OriginalExpiryTime() != Time::NullTTime())

  			    {

  			    iAlarm.OriginalExpiryTime() += offset;

  			    } 		

  		}	

	if	(iAlarm.HasAssociatedData())

		{

		//Storing the data in the server for the test session to read..

		iAlarmAssociatedDataSize = aMessage.GetDesLengthL(2);

		HBufC8* data = HBufC8::NewLC(iAlarmAssociatedDataSize);

		TPtr8 pData(data->Des());

		aMessage.ReadL(KSlot2, pData);

		iServer->SetAttachment(data);  //Server takes an ownership

		CleanupStack::Pop(data);

		}

	else

		iAlarmAssociatedDataSize = 0;

	}

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

void CConsoleAlarmAlertSession::GetUserTimeL(const RMessage2& aMessage)

	{

	TTime time;

	time.UniversalTime();

	time+=TTimeIntervalMinutes(iConsole->GetTimeInterval());

	TPtrC8 pTime((TUint8 *)&time,sizeof(TTime));

	aMessage.WriteL(KSlot0,pTime);

	}

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

void CConsoleAlarmAlertSession::SetDeferTimeL(const RMessage2& aMessage)

	{

	TPckg<TTime> pTime(iDeferTime);

	aMessage.ReadL(KSlot0, pTime);

	}

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

TBool CConsoleAlarmAlertSession::SoundPlaybackCallbackL(TAny* /*aSelf*/)

	{

//	_LIT(KPlayingSound, "Playing sound");

//	User::InfoPrint(KPlayingSound);

	return ETrue;

	}

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

TAny * CConsoleAlarmAlertSession::InstructionSet()

	{

	return iInstructionSet;

	}

/**

Completes the asynchronous EASAltTestOpCodeNotifyOnAlarm request.

@param aAlarm, alarm received with the EASAltOpCodeSetAlarm message.

@param aFullName, owner of the alarm.

@param aData, any data attached with the EASAltOpCodeSetAlarm message.

*/

void CConsoleAlarmAlertSession::NotifyAlarmL(const TASShdAlarm& aAlarm, const TFullName& aFullName, const TDes8& aData)

	{

	TPckgC<TASShdAlarm> pAlarm(aAlarm);

	iAlarmNotify.WriteL(KSlot0, pAlarm);

	if (iAlarmNotify.Int1() != 0) 

		{

		iAlarmNotify.WriteL(KSlot1, aFullName);

		}

	if (aData.Length() <= iAlarmNotify.GetDesLength(KSlot2))

		{

		iAlarmNotify.WriteL(KSlot2, aData);

		}

	iAlarmNotify.Complete(KErrNone);

	}

/**

Completes the asynchronous EASAltTestOpCodeNotifyOnSoundStart request.

@param aId, id of alarm received with the EASAltOpCodeStartPlayingSound message.

@param aFilename, name of sound file to play.

*/

void CConsoleAlarmAlertSession::NotifySoundStartL(const TAlarmId& aId, const TDesC& aFilename)

	{

	TPckgC<TAlarmId> pId(aId);

	iSoundStartNotify.WriteL(KSlot0, pId);

	if(aFilename.Length() <= iSoundStartNotify.GetDesLength(KSlot1))

		{

		iSoundStartNotify.WriteL(KSlot1, aFilename);

		}

	iSoundStartNotify.Complete(KErrNone);

	}

/**

Completes the asynchronous EASAltTestOpCodeNotifyOnSoundStop request.

@param aId, id of alarm received with the EASAltOpCodeStopPlayingSound message.

*/

void CConsoleAlarmAlertSession::NotifySoundStopL(const TAlarmId& aId)

	{

	TPckgC<TAlarmId> pId(aId);

	iSoundStopNotify.WriteL(KSlot0, pId);

	iSoundStopNotify.Complete(KErrNone);

	}

/**

Completes the asynchronous EASAltTestOpCodeNotifyOnVisible request.

@param aId, id of alarm received with the EASAltOpCodeVisible message.

@param aVisible, visible status received with the EASAltOpCodeVisible message.

*/

void CConsoleAlarmAlertSession::NotifyVisibleL(const TAlarmId& aId, const TBool aVisible)

	{

	TPckgC<TAlarmId> pId(aId);

	TPckgC<TBool> pVisible(aVisible);

	iVisibleNotify.WriteL(KSlot0, pId);

	iVisibleNotify.WriteL(KSlot1, pVisible);

	iVisibleNotify.Complete(KErrNone);

	}

/**

Completes the asynchronous EASAltTestOpCodeNotifyOnState request.

@param aId, id of alarm received with the EASAltOpCodeSetState message.

@param aState, state received with the EASAltOpCodeSetState message.

*/

void CConsoleAlarmAlertSession::NotifyStateL(const TAlarmId& aId, const TInt aState)

	{

	TPckgC<TAlarmId> pId(aId);

	TPckgC<TInt> pState(aState);

	iStateNotify.WriteL(KSlot0, pId);

	iStateNotify.WriteL(KSlot1, pState);

	iStateNotify.Complete(KErrNone);

	}

/**

Completes the asynchronous EASAltTestOpCodeNotifyOnDelete request.

@param aId, id of alarm received with the EASAltOpCodeDelete message.

*/

void CConsoleAlarmAlertSession::NotifyDeleteL(const TAlarmId& aId)

	{

	TPckgC<TAlarmId> pId(aId);

	iDeleteNotify.WriteL(KSlot0, pId);

	iDeleteNotify.Complete(KErrNone);

	}

/**

When in multiple alarm mode this method handles the dispatching of messages.

@param aMessage, the message to dispatch.

@return ETrue if this message should be completed with KErrNone on return.

		EFalse if this message shouldn't be completed on return.

*/

TBool CConsoleAlarmAlertSession::MultiDispatchL(const RMessage2& aMessage)

	{

	TBool complete = ETrue;

	switch(aMessage.Function())

		{

	case EASAltOpCodeNotify:

		iMsgPtr = aMessage;

		iServer->SetNotifyMessage(&iMsgPtr);

		complete = EFalse;	

		break;

	case EASAltOpCodeNotifyCancel:

		iServer->NotifyMessage()->Complete(KErrCancel);

		iServer->SetNotifyMessage(NULL);

		complete = EFalse;

		break;

	case EASAltOpCodeVisible:

		CmdVisibleL(aMessage);

		break;

	case EASAltOpCodeSetState:

		CmdSetStateL(aMessage);

		break;

	case EASAltOpCodeSetAlarm:

		CmdSetAlarmL(aMessage);

		break;

	case EASAltOpCodeSetDeferTime:

		CmdSetDeferTimeL(aMessage);

		break;

	case EASAltOpCodeGetEndQuietTime:

	case EASAltOpCodeGetUserTime:

		CmdGetUserTimeL(aMessage);

		break;

	case EASAltOpCodeLogon:

		complete = EFalse;	

		break;

	case EASAltOpCodeStartPlayingSound:

		CmdStartPlayingSoundL(aMessage);

		break;

	case EASAltOpCodeStopPlayingSound:

		CmdStopPlayingSoundL(aMessage);

		break;

	case EASAltOpCodeVisibleAll:

	case EASAltOpCodeSetStateAll:

	case EASAltOpCodeStopPlayingSoundAll:

		break;