// Copyright (c) 2005-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:

// Contains implementation of CTestStartAlertServerStep class

// 

//

/**

 @file

 @internalTechnology 

*/

// User Include

#include "TestStartAlertServerStep.h"

#include "AlarmControlsManager.h"

// System Include

#include <uikon/eikalsrv.h>

/**

Constructor. Sets the test step name. Testserver reference passed to make use 

of TEF's method of sharing data between test steps

Max alarms defaults to 1 if not mentioned in ini

@internalTechnology

@test

*/

CTestStartAlertServerStep::CTestStartAlertServerStep(CTestMultipleAlarmsServer& aTestServer) 

: CTestBaseStep(aTestServer)

	{

	//Call base class method to set human readable name for test step

	SetTestStepName(KTestStartAlertServerStep);

	}

/**

Base class pure virtual.

@return		EPass or EFail indicating the result of the test step.

@internalTechnology

@test

*/

TVerdict CTestStartAlertServerStep::doTestStepL()

	{

	TInt maxAlarms;

	if(!ReadIntsFromConfig(ConfigSection(), &KIniMaxAlarms(), &maxAlarms, NULL))

		{

		INFO_PRINTF1(_L("maxalarms value not found in ini. maxalarms will hence default to 1"));

		maxAlarms = 1;

		}

	// Let the test server record the current maxalarms value, to share it 

	// with other test steps

	TestServer()->CurrentMaxAlarms() = maxAlarms;

	PrintIfError(CreateThreadAndStartAltSrv());

	return TestStepResult();	

	}

/**

Starts the alarm alert server

@param aTestStep Pointer to the CTestStartAlertServerStep.

@internalTechnology

@test

*/

LOCAL_C void StartAlarmAlertServer(CTestMultipleAlarmsServer* aTestServer)

	{

	const TInt KMaxAttempts = 5;

	TInt error = KErrNone;

	CEikServAlarmAlertServer* alertServer = NULL;

	CAlarmControlsManager *manager = NULL;

	TRAP(error, manager = CAlarmControlsManager::NewL(*aTestServer));

	if(error == KErrNone)

		{

		aTestServer->AlarmControlsManager() = manager;

		for(TInt attempt = 0; attempt < KMaxAttempts; ++attempt)

			{

			if(aTestServer->CurrentMaxAlarms() == 1)

				{// Calling the single alarm notification version. Can still call the multiple alarm 

				 // version with 1 as maxalarms value, but still just to cover the existing API too.

				TRAP(error, alertServer = CEikServAlarmAlertServer::NewL(manager));

				}

			else

				{// Multiple alarm version

				TRAP(error, alertServer = CEikServAlarmAlertServer::NewL(manager, aTestServer->CurrentMaxAlarms()));

				}

			if(error != KErrAlreadyExists)

				{// Although the thread is shown as dead, EPOC seems to do some

				 // background closing operations, and does not allow us to create a 

				 // thread with the same name till then. So we try a few more times

				 // only if it is KErrAlreadyExists

				break;

				}

			}

		}

	// Tell the test step thread about the status	

	RThread::Rendezvous(error);

	if(error == KErrNone)

		{

		aTestServer->AlertServer() = alertServer;

		// enter the active scheduler if everything is ok

		CActiveScheduler::Start();

		// When thread exits, clean up

		delete (aTestServer->AlertServer());

		delete (aTestServer->AlarmControlsManager());

		}	

	}

/**

Thread entry point

@return Error code of the operation performed

@internalTechnology

@test

*/

static TInt ThreadStartFn(TAny* aPtr)

	{

	__UHEAP_MARK;

	CActiveScheduler* sched = new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(sched);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(cleanup == NULL)

		{

		delete sched;

		return KErrNoMemory;

		}

	CTestMultipleAlarmsServer* testServer = (static_cast<CTestStartAlertServerStep*>(aPtr))->TestServer();	

	StartAlarmAlertServer(testServer);

	delete sched;

	delete cleanup;

	__UHEAP_MARKEND;

	return KErrNone;

	}

/**

Starts the alarm alert server

@param aMaxAlarms Maximum number of alarms for which we want the alert server 

to notify at a time	

@return The error code

@internalTechnology

@test

*/

TInt CTestStartAlertServerStep::CreateThreadAndStartAltSrv()

	{

	_LIT(KChildThreadName, "ChildThreadThatStartsAlarmAlertServerInAlarmAlertServerTests");

	TBuf<65> childThreadName(KChildThreadName);

	RThread childThread;

	const TInt KMaxTestThreadHeapSize = 0x10000;

	TInt err =	childThread.Create(

				childThreadName,

				ThreadStartFn,

				KDefaultStackSize,

				KMinHeapSize,

				KMaxTestThreadHeapSize,

				this,			

				EOwnerProcess);

	if(err == KErrNone)

		{

		TRequestStatus status;

		childThread.Rendezvous(status);

		if(status != KRequestPending)

			{

			childThread.Kill(0);

			}

		else	

			{

			childThread.Resume();

			// Cache the thread handle, so as to examine its death later

			TestServer()->AltSrvThread() = childThread;

			INFO_PRINTF2(_L("<B>Alert Server thread has started, Max alarms = %D</B>"), TestServer()->CurrentMaxAlarms());

			}

		User::WaitForRequest(status);

		// Examine the child thread's exit type and reason.

		// If it is a panic, it can be KErrNone too, and if so, make it KErrGeneral,

		// so that the Test Step does not wrongly EPass seeing KErrNone in err.

		// The Kern-Exec Panic 0 information will not be lost either, as each test

		// step checks and displays this in its Postamble.

		err = (childThread.ExitType()==EExitPanic && childThread.ExitReason() == KErrNone

			  ) ? KErrGeneral : status.Int();

		}

	return err;	

	}