// 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());

 	}