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

//

/**

 @file

*/

#include "FLOGSVR.H"

#include "FLOGMAN.H"

#include "FLOGSTD.H"

/**

@internalComponent

*/

const TInt KOpenLogFilesGranularity=5;

/* Internal error. Use positive number to ensure no conflict with other error code

    Indicate that client message has panic'ed and should not be completed.

*/

const TInt KErrMessagePanic = 1;  

/**

panics for log client

@internalComponent

*/

enum TLogClientPanic 

    {

	ELogDirectoryNameDoesNotExist =1,   ///<  panic if no log directory name 

	ELogFileNameDoesNotExist	        ///< panic if file name doesnot exist 

	};

/**

CFileLoggerServer class definition

*/

CFileLoggerServer* CFileLoggerServer::NewL()

/**

Creates new CFileLoggerServer object

@return Pointer to CFileLoggerServer object

*/

	{

	CFileLoggerServer* r=new(ELeave) CFileLoggerServer();

	CleanupStack::PushL(r);

	r->ConstructL();

	r->StartL(KFLoggerServerName);

	CleanupStack::Pop();

	return r;

	}

CFileLoggerServer::CFileLoggerServer()

 	: CServer2(EPriority)

 	{}

void CFileLoggerServer::ConstructL()

	{

	iLoggerManager=CFileLoggerManager::NewL();

	iSessionCounter=CFileLogSessionCounter::NewL();

	}

CFileLoggerServer::~CFileLoggerServer()

/**

Destructor

*/

	{

	delete iSessionCounter;

	delete iLoggerManager;

	}

CFileLogSessionCounter* CFileLoggerServer::SessionCounter() const

	{

	return iSessionCounter;

	}

void CFileLoggerServer::Error(TInt aError)

	{

	Message().Complete(aError);

	ReStart();

	}

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

/**

Create a new server session. Check we're the right version and make a new session

@param aVersion version of new session

*/

	{

	TVersion v(KFLogSrvMajorVersionNumber,KFLogSrvMinorVersionNumber,KFLogSrvBuildVersionNumber);

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

		User::Leave(KErrNotSupported);

	iSessionCounter->CancelTimer();

	return CFileLogSession::NewL(CONST_CAST(CFileLoggerServer*,this),iLoggerManager);

	}

/**

CFileLogSessionCounter class definition 

*/

CFileLogSessionCounter* CFileLogSessionCounter::NewL()

/**

Creates new CFileLogSessionCounter object

@return Pointer to CFileLogSessionCounter object

*/

	{

	CFileLogSessionCounter* r=new(ELeave) CFileLogSessionCounter();

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop();

	return r;

	}

CFileLogSessionCounter::~CFileLogSessionCounter()

/**

Destructor

*/

	{

	delete iShutdownTimer;

	}

CFileLogSessionCounter::CFileLogSessionCounter()

	: iSessionCount(0)

/**

Default Constructor

*/

	{}

void CFileLogSessionCounter::ConstructL()

	{

	iShutdownTimer=CShutdownTimer::NewL();

	}

void CFileLogSessionCounter::IncrementSessionCount()

/**

Increments the Session count 

*/

	{

	iSessionCount++;

	}

void CFileLogSessionCounter::DecrementSessionCount()

/**

Decrements the Session count

*/

	{

	iSessionCount--;

	if (iSessionCount<=0)

		iShutdownTimer->After(KShutdownPause);

	}

void CFileLogSessionCounter::CancelTimer()

/**

Cancels the timer 

*/

	{

	iShutdownTimer->Cancel();

	}	

/**

CShutdownTimer class definitions

*/

CShutdownTimer* CShutdownTimer::NewL()

/**

Creates new CShutdownTimer object

@return Pointer to CShutdownTimer object

*/

	{

	CShutdownTimer* r=new(ELeave) CShutdownTimer();

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop();

	return r;

	}

CShutdownTimer::~CShutdownTimer()

/**

Destructor

*/

	{}

CShutdownTimer::CShutdownTimer()

	: CTimer(EPriorityIdle)

/**

Default Constructor

*/

	{

	CActiveScheduler::Add(this);

	}

void CShutdownTimer::RunL()

/**

*/

	{

	CActiveScheduler::Stop();

	}

/**

CFileLogSession class definition

*/

CFileLogSession* CFileLogSession::NewL(CFileLoggerServer* aServer, CFileLoggerManager* aManager)

 	{

 	CFileLogSession* r=new(ELeave) CFileLogSession(aServer,aManager);

 	CleanupStack::PushL(r);

 	r->ConstructL();

 	CleanupStack::Pop();

 	return r;

 	}

CFileLogSession::CFileLogSession( CFileLoggerServer* aServer, CFileLoggerManager* aManager)

 	: CSession2(), iLoggerServer(aServer), iLoggerManager(aManager)

 	{}

void CFileLogSession::ConstructL()

	{

	iLoggerServer->SessionCounter()->IncrementSessionCount();		// should be done first because it will be decremented in the destructor

	iOpenLogFiles=new(ELeave) CArrayFixFlat<TLogFile>(KOpenLogFilesGranularity);

 	}

CFileLogSession::~CFileLogSession()

/**

Destructor

*/

	{

	if  (iOpenLogFiles)

		{

	TInt count=iOpenLogFiles->Count();

	TInt i;

	for (i=0; i<count; i++)

		{

		iLoggerManager->CloseLog(iOpenLogFiles->At(i));

		}

	iOpenLogFiles->Delete(0,count);

	delete iOpenLogFiles;

		}

	iLoggerServer->SessionCounter()->DecrementSessionCount();		// starts the timer if this is the last session

	}

void CFileLogSession::ServiceL(const RMessage2& aMessage)

/**

@internalTechnology

*/

	{

 	TRAPD(ret,DispatchMessageL(aMessage));

 	if (ret!=KErrMessagePanic)

 	    {

        aMessage.Complete(ret);

 	    }

 	}

void CFileLogSession::DispatchMessageL(const RMessage2& aMessage)

 	{

 	TInt func=aMessage.Function();

 	if (func!=ECreateLog && func!=EWriteLog && func!=ECloseLog && func!=ECreateWriteAndCloseLog)

 		User::Leave(KErrNotSupported);

 	TLogFile log;

 	TPckg<TLogFile> logPckg(log);

 	aMessage.ReadL(0,logPckg);

 	if (log.Directory().Length()<=0)

        {

        aMessage.Panic(KFLoggerServerName,ELogDirectoryNameDoesNotExist);

        User::Leave(KErrMessagePanic);

        }

    if (log.Name().Length()<=0)

        {

        aMessage.Panic(KFLoggerServerName,ELogFileNameDoesNotExist);

        User::Leave(KErrMessagePanic);

        }

 //	TBuf8<KLogBufferSize> buf;

 	TBuf8<1600> buf;

 	if (func==EWriteLog || func==ECreateWriteAndCloseLog)

 	    {

 		aMessage.ReadL(1,buf);

 	    }

 	switch (func)

 		{

 	case ECreateLog:

 		OpenLogL(log);

 		aMessage.WriteL(0,logPckg);

 		break;

 	case EWriteLog:

 		iLoggerManager->WriteToLogL(log,buf);

 		break;

 	case ECloseLog:

 		CloseLog(log);

 		break;

 	case ECreateWriteAndCloseLog:

  		{

  		OpenLogL(log); // Ok to leave here; assume that log not left open

 		TInt rc = aMessage.Write(0,logPckg);

  		if (rc == KErrNone && log.Valid())

  			TRAP(rc,iLoggerManager->WriteToLogL(log,buf));

    		CloseLog(log);

  		User::LeaveIfError(rc);

    		break;

  		}

 	default:

 		User::Leave(KErrNotSupported);

 		break;

 		}

 	}

void CFileLogSession::OpenLogL(TLogFile& aLogFile)

/**

Opens log file

@param aLogFile Log file name

*/

	{

	iOpenLogFiles->AppendL(aLogFile);

	iLoggerManager->FindOrCreateLogL(aLogFile);

	}

void CFileLogSession::CloseLog(TLogFile& aLogFile)

/**

Closes the log file

@param aLogFile Log file name

*/

	{

	iLoggerManager->CloseLog(aLogFile);

	TInt count=iOpenLogFiles->Count();

	TInt i=0;

	for (i=0; i<count; i++)

		{

		if (iOpenLogFiles->At(i)==aLogFile)

			{

			iOpenLogFiles->Delete(i,1);

			break;

			}

		}	

	__ASSERT_DEBUG(i<=count, User::Invariant());

	}