// 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 the License "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 "consolealarmalertconsole.h"

// System includes

#include <e32twin.h>

#include <e32base.h>

#include <e32svr.h>

// User includes

#include "asaltdefs.h"

#include "consolealarmalertsession.h"

// Type definitions

// Constants

// Enumerations

// Classes referenced

///////////////////////////////////////////////////////////////////////////////////////

// ----> CConsoleAlarmAlertConsole (source)

///////////////////////////////////////////////////////////////////////////////////////

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

CConsoleAlarmAlertConsole::CConsoleAlarmAlertConsole(CConsoleAlarmAlertSession& aSession)

:	CActive(CActive::EPriorityLow), iSession(aSession), iInstructionIndex(0)

	{

	CActiveScheduler::Add(this);

	}

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

CConsoleAlarmAlertConsole::~CConsoleAlarmAlertConsole()

	{

	Cancel();

	Hide();

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

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

void CConsoleAlarmAlertConsole::GetKey()

	{

	if	(iWin && !IsActive())

		{

		SetActive();

		iWin->Read(iStatus);

		}		

	}

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

void CConsoleAlarmAlertConsole::CancelKey()

	{

	if	(IsActive())

		Cancel();

	}

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

void CConsoleAlarmAlertConsole::DecCounter()

	{

	if	(iTimeInterval > 0)

		{

		--iTimeInterval;

		UpdateDisplay();

		}

	}

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

void CConsoleAlarmAlertConsole::UpdateDisplay()

	{

	TBuf<180> buf;

	_LIT(KEalwlAlarmSoundOff, "Off");

	_LIT(KEalwlAlarmSoundOn, "On");

	_LIT(KEalwlStatusEnabled, "Are");

	_LIT(KEalwlStatusNotEnabled, "Are Not");

	_LIT(KEalwlStatusIs, "Is");

	_LIT(KEalwlStatusIsNo, "Is No");

	//

	if	(!iWin)

		return;

	iWin->SetCursorPosAbs(TPoint(0,0));

	// MESSAGE

	buf.Format(_L("Message : %S"), &iSession.Alarm().Message());

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	// DATA

	if	(iSession.Alarm().HasAssociatedData())

		{

		const TAgnAlarmInfo data = iSession.AlarmData();

		const TUid KUidAgendaModelAlarmCategory = { 0x101F4A70 };

		if (data.iAlarmCategory == KUidAgendaModelAlarmCategory)

			{

			_LIT(KEalwlAgendaData,"\ndata: agenda filename \"%S\"");

			if (data.iFileName.Length() < 40)

				buf.Format(KEalwlAgendaData,&data.iFileName);

			else

				{

				TBuf<40> temp = data.iFileName.Left(40);

				buf.Format(KEalwlAgendaData,&temp);

				}

			}

		else

			buf.Format(_L("\nAlarm has %d data bytes"), iSession.AlarmDataSize());

		}

	else

		{

		buf = _L("\nAlarm has no associated data");

		}

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	// DEFER TIME

	if	(iSession.DeferTime() != Time::NullTTime())

		{

		TDateTime dateTime(iSession.DeferTime().DateTime());

		buf.Format(_L("\nDefer   : %02d:%02d"), dateTime.Hour(), dateTime.Minute());

		}

	else

		buf=_L("\nNULL defer time");

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	// TIME INTERVAL

	buf.Format(_L("\nCurrent time interval is %d minutes"), GetTimeInterval());

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	// STATE FLAGS

	buf.Format(_L("\nAlarm sounds are %S"),(iAlertState&EASAltStateFlagsSilentRunning)?&KEalwlAlarmSoundOff:&KEalwlAlarmSoundOn);

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	buf.Format(_L("\nAlarm sounds %S paused"),(iAlertState&EASAltStateFlagsSoundIsPaused)?&KEalwlStatusEnabled:&KEalwlStatusNotEnabled);

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	buf.Format(_L("\nAlarm sounds %S deferred"),(iAlertState&EASAltStateFlagsInQuietPeriod)?&KEalwlStatusEnabled:&KEalwlStatusNotEnabled);

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	buf.Format(_L("\nThere %S more than one unacknowledged alarms"),(iAlertState&EASAltStateFlagsMoreThanOneDueAlarm)?&KEalwlStatusEnabled:&KEalwlStatusNotEnabled);

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	buf.Format(_L("\nThere %S memory to snooze alarms"),(iAlertState&EASAltStateFlagsNoMemoryForSnoozeAlarm)?&KEalwlStatusIsNo:&KEalwlStatusIs);

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	buf.Format(_L("\nThere %S an alarm sound to play"),(iAlertState&EASAltStateFlagsAlarmHasNoSoundFileName)?&KEalwlStatusIsNo:&KEalwlStatusIs);

	iWin->Write(buf);

	iWin->ClearToEndOfLine();

	// COMMAND PROMPTS

	iWin->Write(_L("\nENTER = Silence alarm          SPACE = Quiet Period"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\nESCAPE = Acknowledge alarm     A = Acknowledge all"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\nP = Pause alarm sound          TAB = Snooze alarm"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\n1 = 1 min sound interval		 0 = 0 mins sound interval"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\n+ = Increase int. and pause    - = Decrease int. and pause"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\n! = Kill alarm alert server"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\n"));

	iWin->ClearToEndOfLine();

	iWin->Write(_L("\r"));

	//

	if(!iSession.InstructionSet()) //Get user input if instruction set unspecified.

		GetKey();

	else if (iInstructionIndex >= static_cast<RArray<TInt>*>(iSession.InstructionSet())->Count()) //Get user input if program has already iterated thru entire instruction set.

		GetKey();

	else //Use the command in the instruction set, instead of waiting for user input.

		{

			if(!IsActive())

			{

			iStatus = KRequestPending;

			TRequestStatus* ptrStatus = &iStatus;

			User::RequestComplete( ptrStatus, KErrNone );

			SetActive();

			}

		}

	}

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

TInt CConsoleAlarmAlertConsole::GetTimeInterval() const

	{

	return(iTimeInterval);

	}

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

void CConsoleAlarmAlertConsole::SetVisibility(TInt aVis)

	{

	if	(!aVis)

		Hide();

	else if (!iWin)

		{

		// Create a new window, since cannot set order of console windows

		CreateWin();

		UpdateDisplay();

		}

	}

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

void CConsoleAlarmAlertConsole::SetAlertState(TInt aFlags)

	{

	iAlertState = aFlags;

	UpdateDisplay();

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

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

void CConsoleAlarmAlertConsole::RunL()

	{

	if (iStatus.Int() == KErrCancel)

		return;

	__ASSERT_DEBUG(iWin, User::Invariant());

	TInt key = iWin->KeyCode();

	if(iSession.InstructionSet() && iInstructionIndex < static_cast<RArray<TInt>*>(iSession.InstructionSet())->Count())

		{

		RArray<TInt>* temp = static_cast<RArray<TInt>*>(iSession.InstructionSet());

		key = (*temp)[iInstructionIndex++];

		GetKey();

		}

	else

		{

		GetKey();

		if ((key>=EKeyF1 && key<=EKeyF12) || key==EKeyTab)

			{

			DoDeferTime(EASAltAlertServerResponseSnooze);

			}

		}

	switch (key)

		{

	// ACKNOWLEDGE CURRENT

	case EKeyEscape:

		iSession.Notify(EASAltAlertServerResponseClear);

		return;

	// ACKNOWLEDGE ALL

	case 'a':

	case 'A':

		iSession.Notify(EASAltAlertServerResponseClearAll);

		return;

	// QUIET PERIOD

	case EKeySpace:

		DoDeferTime(EASAltAlertServerResponseQuietPeriod);

		break;

	// PAUSE SOUND

	case 'p':

	case 'P':

		DoDeferTime(EASAltAlertServerResponsePauseSound);

		break;

	// SILENCE ALL SOUND

	case EKeyEnter:

		iSession.Notify(EASAltAlertServerResponseSilence);

		break;

	// INTERVAL 1 MINUTE

	case '1':

		iTimeInterval=1;

		iSession.Notify(EASAltAlertServerResponsePauseSound);

		break;

	// INTERVAL 0 MINUTES

	case '0':

		iTimeInterval=0;

		iSession.Notify(EASAltAlertServerResponsePauseSound);

		break;

	// PAUSE +

	case '=':

	case '+':

		iTimeInterval++;

		iSession.Notify(EASAltAlertServerResponsePauseSound);

		break;

	// PAUSE -

	case '-':

		iTimeInterval--;

		iSession.Notify(EASAltAlertServerResponsePauseSound);

		break;

	// QUIT

	case '!':

		CActiveScheduler::Stop();

		break;

		}

	TBuf<10> buf;

	buf.Format(_L("'%c',"), key);

	iWin->Write(buf);

	}

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

void CConsoleAlarmAlertConsole::DoCancel()

	{

	__ASSERT_DEBUG(iWin, User::Invariant());

	iWin->ReadCancel();

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

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

void CConsoleAlarmAlertConsole::Hide()

	{

	if	(iWin)

		CancelKey(); 

	//

	delete iWin;

	iWin = NULL;

	//

	if	(iCountDown)

		iCountDown->Cancel();

	//

	delete iCountDown;

	iCountDown=NULL;

	}

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

void CConsoleAlarmAlertConsole::CreateWin()

	{

	_LIT(KAlarmAlertConsoleCaption, "Test Alarm Alert Server Console");

	//

	__ASSERT_DEBUG(!iWin, User::Invariant());

	__ASSERT_DEBUG(!iCountDown, User::Invariant());

	//

	TRAPD(trapCheck, iWin = Console::NewL(KAlarmAlertConsoleCaption, TSize(KConsFullScreen, KConsFullScreen)));

	if	(trapCheck)

		{

		iWin=NULL;

		return;

		}

	TRAP(trapCheck, iCountDown = CPeriodic::NewL(CActive::EPriorityIdle));

	if	(trapCheck)

		{

		iCountDown=NULL;

		return;

		}

	//

	const TTimeIntervalMicroSeconds32 interval(60000000);

	iCountDown->Start(interval, interval, TCallBack(&CountDownCallBack, this));

	}

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

void CConsoleAlarmAlertConsole::DoDeferTime(TASAltAlertServerResponse aResponse)

	{

	if	(++iTimeInterval > 60)

		{

		iTimeInterval = 5;

		User::Beep(440, 12);

		}

	//

	TTime now;

	now.HomeTime();

	now += TTimeIntervalMinutes(iTimeInterval);

	//

	iSession.Notify(aResponse, now);

	}

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

TBool CConsoleAlarmAlertConsole::CountDownCallBack(TAny* aSelf)

	{

	CConsoleAlarmAlertConsole& self = *reinterpret_cast<CConsoleAlarmAlertConsole*>(aSelf);

	self.DecCounter();

	//

	return EFalse;

	}