/*

* Copyright (c) 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 Files  

#include <e32base.h>

#include <f32file.h> 

#include "STFLogServer.h"

#include "STFLoggerCSCommon.h"

// Called by the CServer framework

void CSTFLogSession::CreateL()

	{

	CSTFLogServer* server = static_cast<CSTFLogServer*>(const_cast<CServer2*>(Server()));

	ASSERT(server);

	server->AddSession();

	iLogger = NULL;

	}

CSTFLogSession::~CSTFLogSession()

	{

	CSTFLogServer* server = static_cast<CSTFLogServer*>(const_cast<CServer2*>(Server()));

	ASSERT(server);

	server->RemoveSession();

	if(iLogger)

	    {

        delete iLogger;

        iLogger = 0;

	    }

	}

// Handle a client request

// Leaves are handled by CHerculeanSession::ServiceError()

void CSTFLogSession::ServiceL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

		case (ESTFLogger_CreateLogger):

			CreateLogger(aMessage);

			break;

		case (ESTFLogger_Log_TInt_TDesC):

			Log_TInt_TDesCL(aMessage);

			break;

		case (ESTFLogger_Log_TInt_TDesC8):

			Log_TInt_TDesC8L(aMessage);

			break;

		case (ESTFLogger_CreationResult):

			CreationResult(aMessage);

			break;

		case (ESTFLogger_OutputType):

			OutputType(aMessage);

			break;

		default:

			PanicClient(aMessage,EPanicNotSupported);

		break;

		}

	}

// Handles leaves from CSTFLogSession::ServiceL()

// A bad descriptor error implies a badly programmed client, so panic it

// Report other errors to the client by completing the outstanding request with the error

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

	{

	if (KErrBadDescriptor==aError)

		PanicClient(aMessage,EPanicBadDescriptor);

	else

		aMessage.Complete(aError);

	}

void CSTFLogSession::CreateLogger(const RMessage2& aMessage)

    {

    TSTFLoggerCreateData loggerCreateData;

    TPckg<TSTFLoggerCreateData> pckgData(loggerCreateData);

    aMessage.Read(0,pckgData);

    TInt err;

    if(!iLogger)

        {

        TRAP(err, iLogger = CStifLoggerBase::NewL( loggerCreateData.iTestPath,

                                                loggerCreateData.iTestFile,

                                                loggerCreateData.iLoggerType,

                                                loggerCreateData.iOutput,

                                                loggerCreateData.iOverWrite,

                                                loggerCreateData.iWithTimeStamp,

                                                loggerCreateData.iWithLineBreak,

                                                loggerCreateData.iWithEventRanking,

                                                loggerCreateData.iThreadIdToLogFile,

                                                loggerCreateData.iCreateLogDir,

                                                loggerCreateData.iStaticBufferSize,

                                                loggerCreateData.iUnicode,

                                                loggerCreateData.iThreadId) );

        }

    aMessage.Complete(err); 

    }

void CSTFLogSession::Log_TInt_TDesCL(const RMessage2& aMessage)

	{

	if(!iLogger)

		{

		aMessage.Complete(KErrBadHandle);

		}

	else

		{

		TInt length = aMessage.Int0();

		TInt style = aMessage.Int1();

		RBuf buf;

		buf.CleanupClosePushL();

		buf.Create(length);

		aMessage.Read(2, buf);

		TInt err = iLogger->Log(style, buf);	

		CleanupStack::PopAndDestroy(&buf);

		aMessage.Complete(err);

		}

	}

void CSTFLogSession::Log_TInt_TDesC8L(const RMessage2& aMessage)

	{

	if(!iLogger)

		{

		aMessage.Complete(KErrBadHandle);

		}

	else

		{

		TInt length = aMessage.Int0();

		TInt style = aMessage.Int1();

		RBuf8 buf8;

		buf8.CleanupClosePushL();

		buf8.Create(length);

		aMessage.Read(2, buf8);

		TInt err = iLogger->Log(style, buf8);	

		CleanupStack::PopAndDestroy(&buf8);

		aMessage.Complete(err);

		}

	}

void CSTFLogSession::CreationResult(const RMessage2& aMessage)

	{

	if(!iLogger)

		{

		aMessage.Complete(KErrBadHandle);

		}

	else

		{

		TInt result;

		TPckg<TInt> creationResult(result);

		result = iLogger->CreationResult();

		aMessage.Write(0,creationResult);

		aMessage.Complete(KErrNone);

		}

	}

void CSTFLogSession::OutputType(const RMessage2& aMessage)

	{

	if(!iLogger)

		{

		aMessage.Complete(KErrBadHandle);

		}

	else

		{

		CStifLogger::TOutput outputType;

		TPckg<CStifLogger::TOutput> type(outputType);

		outputType = iLogger->OutputType();

		aMessage.Write(0,type);

		aMessage.Complete(KErrNone);

		}

	}

CServer2* CSTFLogServer::NewLC()

	{

	CSTFLogServer* self=new(ELeave) CSTFLogServer;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

// Starts the server and constructs the shutdown object, starting the timer to ensure that

// the server will exit even if the starting client connection fails

void CSTFLogServer::ConstructL()

	{

	StartL(KSTFLoggerServerName);

	iShutdown.ConstructL();

	iShutdown.Start();

	}

// Example doesn't bother checking the version

CSession2* CSTFLogServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

	{

	return new(ELeave) CSTFLogSession();

	}

// Cancel the shutdown timer now, the new session is connected

void CSTFLogServer::AddSession()

	{

	++iSessionCount;

	iShutdown.Cancel();  // Cancel any outstanding shutdown timer

	}

// Decrement the session counter and start the shutdown timer if the last client has disconnected

void CSTFLogServer::RemoveSession()

	{

	if (--iSessionCount==0)

		iShutdown.Start();

	}

// Initiates server exit when the timer expires

void CShutdown::RunL()

	{

	CActiveScheduler::Stop();

	}

void PanicClient(const RMessage2& aMessage,TServerPanic aPanic)

	{

	_LIT(KPanic,"STFLoggingServer");

	aMessage.Panic(KPanic,aPanic);

	}

// Initialize and run the server

static void RunTheServerL()

	{// First create and install the active scheduler

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	// create the server

	CSTFLogServer::NewLC();

	// Naming the server thread after the server helps to debug panics

	User::LeaveIfError(User::RenameThread(KSTFLoggerServerName));

	RProcess::Rendezvous(KErrNone);

	// Enter the wait loop

	CActiveScheduler::Start();

	// Exited - cleanup the server and scheduler

	CleanupStack::PopAndDestroy(2, scheduler);

	}

// Server process entry-point

TInt E32Main()

	{

	__UHEAP_MARK; // Heap checking

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

		TRAP(r,RunTheServerL());

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return r;

	}