// Copyright (c) 2002-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 <e32svr.h>

 #include "TestFrameworkServer.h"

 #include "TestFrameworkServer.inl"

 #include <testframeworkipc.h>

 /**

  *

  * Initiate server exit when the timer expires

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServerShutdown::RunL()

 	{

 	CActiveScheduler::Stop();

 	}

 /**

  *

  * Test Framework server static constructor

  * NOTE : only one instance of the server process should run

  * during any Test Framework run; all client sessions

  * will use this one instance.

  *

  * @xxxx

  * 

  */

 CMmfIpcServer* CTestFrameworkServer::NewL()

 	{

 	CTestFrameworkServer* s = new(ELeave) CTestFrameworkServer;

 	CleanupStack::PushL(s);

 	s->ConstructL();

 	CleanupStack::Pop();

 	return s;

 	}

 /**

  *

  * Test Framework server first-phase constructor

  *

  * @xxxx

  * 

  */

 CTestFrameworkServer::CTestFrameworkServer()

 	:CMmfIpcServer(0, ESharableSessions)

 	{

 	}

 // set up so that iConsole is NULL. A call to OpenLogL will initialise the console

 // and file (if any)

 /**

  *

  * Test Framework server second-phase constructor

  * Starts the server; does not initialise the log

  * (this must be done independently with a call to OpenLogL)

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServer::ConstructL()

 	{

 	StartL(KTestFrameworkServerName);

 	//Ensure that the server will exit even if the first client fails to connect

 	iShutdown.ConstructL();

 	iShutdown.Start();

 	iLogMode = 0;	// initial value : not running any log

 	iConsole = NULL;

 	iFileLogger = NULL;

 	}

 /**

  *

  * Test Framework server destructor

  *

  * @xxxx

  * 

  */

 CTestFrameworkServer::~CTestFrameworkServer()

 	{

 	CloseLog();

 	}

 /**

  *

  * Create new server session.

  *

  * @param	"const TVersion &aVersion"

  *			Server version (required)

  *

  * @return	"CSharableSession*"

  *			The created server session.

  * 

  * @xxxx

  * 

  */

 CMmfIpcSession* CTestFrameworkServer::NewSessionL(const TVersion &aVersion) const

 	{

 	TVersion ver(KTestFrameworkServerMajorVersionNumber,

 			     KTestFrameworkServerMinorVersionNumber,

 			     KTestFrameworkServerBuildVersionNumber);

 	if (!User::QueryVersionSupported(ver, aVersion))

 		User::Leave(KErrNotSupported);

 	// make new session

 	return new(ELeave) CTestFrameworkServerSession();

 	}

 /**

  *

  * Add a server session.

  * 

  * @xxxx

  * 

  */

 void CTestFrameworkServer::AddSession()

 	{

 	++iSessionCount;

 	iShutdown.Cancel();

 	}

 /**

  *

  * Drop a server session.

  * 

  * @xxxx

  * 

  */

 void CTestFrameworkServer::DropSession()

 	{

 	if (--iSessionCount <= 0)

 		iShutdown.Start();

 	}

 /**

  *

  * Add an input window (at request from client).

  * 

  * @param	"CTestFrameworkServerSession* aOwner"

  *			Window owning server session

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServer::AddInputWindowL(CTestFrameworkServerSession* aOwner)

 	{

 	if (iInputWindow.HasOwner())

 		User::Leave(KErrAlreadyExists);

 	// else

 	iInputWindow.SetOwner(aOwner);

 	TRect rect;

 	rect.iTl = TPoint(0,0);

 	rect.iBr = TPoint(KConsFullScreen, KConsFullScreen);

 	iInputWindow.SetWinRectAndNotifyOwner(rect);

 	}

 /**

  *

  * Remove an input window (at request from client).

  * 

  * @param	"CTestFrameworkServerSession* aOwner"

  *			Window owning server session

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServer::RemoveWindow(CTestFrameworkServerSession* aOwner)

 	{

 	if (aOwner == iInputWindow.Owner())

 		{

 		iInputWindow.SetOwner(NULL);

 		}

 	}

 /**

  *

  * Open a log.

  * 

  * @param	"const TDesC& aLogName"

  *			The log name

  *

  * @param	"TInt aLogMode"

  *			The log mode (as bitmask of TTestFrameworkLogMode)

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServer::OpenLogL(const TDesC& aLogName, TInt aLogMode)

 	{

 	// NB we need to check if a console is already open - if so, we do NOT

 	// create another one. Ditto with file / port.

 	if(aLogMode & ELogToConsole)

 		{

 		if(!iConsole)

 			{

 			iConsole = CServerConsole::NewL(aLogName);

 			CConsoleBase* theConsole = iConsole->Console();

 			theConsole->Printf(_L("%S : Server log starting\n"), &aLogName);

 			iLogMode |= ELogToConsole;

 			if (aLogMode & ELogConsoleFull)

 				iLogMode |= ELogConsoleFull;

 			}

 		}

 	// NB relative paths will not work with TParse (there is no file server open).

 	// Exception is a bare filename (with no path) : this will be found in root of C:

 	// NOTE! We have no mechanism to notify this error. The console will display

 	// and then exit. The log file cannot be opened.

 	// TO BE ENHANCED - if console is made active, then we can pause

 	if(aLogMode & ELogToFile)

 	{

 		if(!iFileLogger)

 			{

 			TRAPD(err, iFileLogger = CFileLogger::NewL());

 			if(err != KErrNone)

 				{

 				// if we can't create a logger, we panic

 				User::Panic(_L("TestFrameworkServer"), 1);

 				}

 			_LIT(KLogPath, "C:\\Logs\\TestResults");

 			_LIT(KDefault, "C:\\.htm"); 

 			TParse parseLogName;

 			parseLogName.Set(aLogName, NULL, NULL); 

 			TFileName logFilePath;

 			logFilePath = KLogPath;

 			if(parseLogName.PathPresent())

 				logFilePath.Append(parseLogName.Path());

 			else

 				logFilePath.Append(_L("\\"));

 			// overwrite extension if supplied with .htm

 			TParse logFileFullName;

 			TInt returnCode = logFileFullName.Set(KDefault, &logFilePath, &aLogName);

 			if (returnCode == KErrNone)

 				{

 				TInt ret = iFileLogger->Connect();

 				if (ret == KErrNone)

 					{

 					iFileLogger->CreateLog(logFilePath, logFileFullName.NameAndExt());

 					iLogMode |= ELogToFile;

 					}

 				}

 			}

 		}

 	if(aLogMode & ELogToPort)

 		{

 		// RDebug::Print will deal with the serial port, we don't do anything special here

 		iLogMode |= ELogToPort;

 		}

 	}

 /**

  *

  * Write to the log.

  * 

  * @param	"const TDesC& aMsg"

  *			The message string to write

  *

  * @param	"TInt aLogMode"

  *			The log mode (as bitmask of TTestFrameworkLogMode)

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServer::WriteLog(const TDesC& aMsg, TInt aLogMode)

 	{

 	if(aLogMode & ELogToConsole)

 		{

 		if(iConsole)

 			{

 			CConsoleBase* theConsole = iConsole->Console();

 			theConsole->Printf(aMsg);

 			theConsole->Printf(_L("\n")); // add newline

 			}

 		}

 	if(aLogMode & ELogToFile)

 		{

 		if(iFileLogger)

 			{

 			iFileLogger->WriteLog(aMsg);

 			}

 		}

 	if(aLogMode & ELogToPort)

 		{

 		RDebug::Print(aMsg);

 		}

 	}

 /**

  *

  * Close the log.

  * 

  * @xxxx

  * 

  */

 void CTestFrameworkServer::CloseLog()

 	{

 	if (iFileLogger != NULL)

 		iFileLogger->CloseLog();

 	delete(iFileLogger);

 	iFileLogger = NULL;

 	delete(iConsole);

 	iConsole = NULL;

 	iLogMode = 0;

 	}

 /**

  *

  * Get the log status.

  *

  * @return	"TInt"

  *			The log status (as bitmask of TTestFrameworkLogMode)

  *

  * @xxxx

  * 

  */

 TInt CTestFrameworkServer::LogStatus() const

 	{

 	return iLogMode;

 	}

 /**

  *

  * Default window constructor (no owner)

  *

  * @xxxx

  * 

  */

 TWindow::TWindow()

 	{

 	iOwner = NULL;

 	}

 /**

  *

  * Default window constructor

  *

  * @param	"CTestFrameworkServerSession* aOwner"

  *			The window owner

  * @xxxx

  * 

  */

 TWindow::TWindow(CTestFrameworkServerSession* aOwner)

 	{

 	iOwner = aOwner;

 	}

 /**

  *

  * Set the window owner

  *

  * @param	"CTestFrameworkServerSession* aOwner"

  *			The window owner

  * @xxxx

  * 

  */

 void TWindow::SetOwner(CTestFrameworkServerSession* aOwner)

 	{

 	iOwner = aOwner;

 	}

 /**

  *

  * Set the window rectangle, and notify owner

  *

  * @param	"const TRect& aWinRect"

  *			The window rectangle

  * @xxxx

  * 

  */

 void TWindow::SetWinRectAndNotifyOwner(const TRect& aWinRect)

 	{

 	if (HasOwner())

 		iOwner->NotifyWindowChanged(aWinRect);

 	}

 /**

  *

  * Does this window have an owner?

  *

  * @return	"TBool"

  *			ETrue if window has an owner

  * @xxxx

  * 

  */

 TBool TWindow::HasOwner()

 	{

 	if (iOwner)

 		return ETrue;

 	return EFalse;

 	}

 /**

  *

  * Server session first-phase constructor

  *

  * @xxxx

  * 

  */

 CTestFrameworkServerSession::CTestFrameworkServerSession()

 	{

 	}

 /**

  *

  * Create a server session.

  *

  * @param "aServer"

  *			The server to add this session to

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServerSession::CreateL(const CMmfIpcServer& aServer)

 	{

 	CMmfIpcSession::CreateL(aServer);	// does not leave

 	//Add session to server first. If anything leaves, it will be removed by the destructor

 	iServer = STATIC_CAST(CTestFrameworkServer*, (CONST_CAST(CMmfIpcServer*, &aServer)));

 	iServer->AddSession();

 	ConstructL();

 	}

 /**

  *

  * Server session second-phase constructor

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServerSession::ConstructL()

 	{

 	}

 /**

  *

  * Server session destructor

  *

  * @xxxx

  * 

  */

 CTestFrameworkServerSession::~CTestFrameworkServerSession()

 	{

 	iServer->RemoveWindow(this);

 	iServer->DropSession();

 	}

 /**

  *

  * Server session service function

  *

  * @param "aMessage"

  *			The message to be serviced.

  *

  * @xxxx

  * 

  */

 void CTestFrameworkServerSession::ServiceL(const RMmfIpcMessage& aMessage)

 	{

 	switch (aMessage.Function())

 		{

 	case ECreateInputWindow:

 		SetOwnCopyOfWindowMessageL(aMessage);

 		iServer->AddInputWindowL(this);

 		break;

 	case ENotifyIfWindowChange:

 		SetOwnCopyOfWindowMessageL(aMessage);

 		break;

 	case ECancelNotifyIfWindowChange:

 		CompleteOwnCopyOfWindowMessage(KErrCancel);

 		aMessage.Complete(KErrNone);

 		break;

 	// logging messages

 	case EOpenLog:

 		{

 		TBuf<KMaxLogFilenameLength> msgBuf;

 		TInt r = MmfMessageUtilX::Read(aMessage, 0, msgBuf);

 		if (r != KErrNone)

 			RunError(aMessage, r);

 		else

 			{

 			iServer->OpenLogL(msgBuf, aMessage.Int1());

 			aMessage.Complete(KErrNone);

 			}

 		}

 		break;

 	case EWriteLog:

 		{

 		TBuf<KMaxLogLineLength> msgBuf;

 		TInt r = MmfMessageUtilX::Read(aMessage, 0, msgBuf);

 		if (r != KErrNone)

 			RunError(aMessage, r);

 		else

 			{

 			iServer->WriteLog(msgBuf, aMessage.Int1());

 			aMessage.Complete(KErrNone);

 			}

 		}

 		break;

 	case ECloseLog:

 		iServer->CloseLog();

 		aMessage.Complete(KErrNone);

 		break;

 	case ELogStatus:

 		{

 		TPckgBuf<TInt> countPckg(iServer->LogStatus());

 		TInt r = MmfMessageUtilX::Write(aMessage, 0, countPckg);

 		if (r != KErrNone)

 			RunError(aMessage, r);

 		else

 			aMessage.Complete(KErrNone);

 		}

 		break;

 	default:

 		// ? should panic here

 		break;

 		}

 	}

 /**

  *

  * Error handler for server session.

  * Completes the pending message using the error code

  *

  * @param	"TInt aError"

  *			The error code

  *

  * @return	"TInt"

  *			The error code (always KErrNone)

  *

  * @xxxx

  *

  */

  TInt CTestFrameworkServerSession::RunError(const RMmfIpcMessage& aMessage, TInt aError)

 	{

 	aMessage.Complete(aError);

 	return KErrNone;

 	}

 /**

  *

  * Set own copy of message.

  * Helper function to enable window change notification.

  *

  * @param "aMessage"

  *			The message to be serviced.

  *

  * @xxxx

  *

  */

  void CTestFrameworkServerSession::SetOwnCopyOfWindowMessageL(const RMmfIpcMessage& aMessage)

 	{

 	if (iCanCompleteWindowMessage)

 		User::Leave(KErrAlreadyExists);

 	//else

 	iWindowMessage = aMessage;

 	iCanCompleteWindowMessage = ETrue;

 	if (iNeedToNotifyClientOfWindowSizeChange)

 		{

 		TInt err = MmfMessageUtil::Write(iWindowMessage, 0, iWinRectBuf);

 		CompleteOwnCopyOfWindowMessage(err);

 		iNeedToNotifyClientOfWindowSizeChange = EFalse;

 		}

 	}

 /**

  *

  * Complete own copy of message.

  * Helper function to enable window change notification.

  *

  * @param "TInt aReason"

  *			The message return code.

  *

  * @xxxx

  *

  */

  void CTestFrameworkServerSession::CompleteOwnCopyOfWindowMessage(TInt aReason)

 	{

 	if (iCanCompleteWindowMessage)

 		iWindowMessage.Complete(aReason);

 	iCanCompleteWindowMessage = EFalse;

 	}

 /**

  *

  * Window change notification.

  *

  * @param "const TRect& aWinRect"

  *			The window rectangle.

  *

  * @xxxx

  *

  */

 void CTestFrameworkServerSession::NotifyWindowChanged(const TRect& aWinRect)

 	{

 	iWinRectBuf() = aWinRect;

 	if (iCanCompleteWindowMessage)

 		{

 		TInt err = MmfMessageUtilX::Write(iWindowMessage, 0, iWinRectBuf);

 		CompleteOwnCopyOfWindowMessage(err);

 		}

 	else

 		{

 		iNeedToNotifyClientOfWindowSizeChange = ETrue;

 		}

 	}

 // EXE/DLL initialisation

 // NOTE! None of this should be built when compiling for Unit Testing

 #if !defined (__TSU_TESTFRAMEWORK__)

 /**

  *

  * Perform all server initialisation, in particular creation of the

  * scheduler and server; then run the scheduler

  *

  *

  * @xxxx

  *

  */

 static void RunServerL()

 	{

 	// create and install the active scheduler we need

 	CActiveScheduler* s = new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(s);

 	CActiveScheduler::Install(s);

 	//

 	// create the server (leave it on the cleanup stack)

 	CleanupStack::PushL(CTestFrameworkServer::NewL());

 	//

 	// Initialisation complete, now signal the client

 	RProcess::Rendezvous(KErrNone);

 	//

 	// Ready to run

 	CActiveScheduler::Start();

 	//

 	// Cleanup the server and scheduler

 	CleanupStack::PopAndDestroy(2);

 	}

 /**

  *

  * Main entry point for the server thread

  *

  * @param "TTestFrameworkServerStart& aStart"

  *			The server starter.

  *

  * @xxxx

  *

  */

 static TInt RunServer()

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TInt r = KErrNoMemory;

 	if (cleanup)

 		{

 		TRAP(r, RunServerL());

 		delete cleanup;

 		}

 	//

 	__UHEAP_MARKEND;

 	return r;

 	}

 GLDEF_C TInt E32Main()

 // Server process entry-point

 // Recover the startup parameters and run the server

 	{

 	TInt r = RunServer();

 	return r;

 	}

 #endif // __TSU_TESTFRAMEWORK__