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

// Flogger File and Serial logger header

// 

//

/**

 @file

 @internalComponent

*/

#ifndef __COMSDBGWRITER_H__

#define __COMSDBGWRITER_H__

#include <e32base.h>

#include <f32file.h>

#include <s32file.h>

#include <d32comm.h>

#include <platform/opensystemtrace.h>

#include "comsdbgsvr.h"

_LIT8(KTimeFormat,"#Time = hh:mm:ss\r\n");

const TInt KHourOffset = 8;

const TInt KMinuteOffset = 11;

const TInt KSecondOffset = 14;

const TInt KTimeStringLength = 18;

class MLogMessageProtocol

	{

public:

	virtual void ClearLog(const TFullName& aName) = 0;

	virtual void SetTimeL(const TTime& aTime) = 0;

	virtual void LogString(const TDesC8& aLogString, const TDesC8& aSubSystem, const TDesC8& aComponent, const TThreadId& aThreadId) = 0;

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent) = 0;

	virtual void LogComment(const TDesC8& aComment) = 0;

	virtual void MediaUpdate(const TDesC8& aMediaSetting, const TBool aForceFlush, const TDesC8& aLogPathSetting) = 0;

	virtual void ShutDown() = 0;

	};

class CLoggerMediaBase;

class MLogArrayAccess;

/**

 * CLogManager - second/consumer/slave thread

 *

 * This class is responsible for implementing the second thread which

 * removes items from the logging queue and writes them to disk.

 * Maintains a pointer to the server's log queue, and a pointer to the

 * media base in use.

 */

class CLogManager : public CBase, public MLogMessageProtocol

	{

public:

	~CLogManager();

	static CLogManager* NewL(MLogArrayAccess& aArrayAccess);

	static TInt ThreadEntryPoint(TAny* aPtr);

	static void DoRunThreadL(MLogArrayAccess& aArrayAccess);

	//from MLogMessageProtocol

	virtual void ClearLog(const TFullName& aName);

	virtual void SetTimeL(const TTime& aTime);

	virtual void LogString(const TDesC8& aLogString, const TDesC8& aSubSystem, const TDesC8& aComponent, const TThreadId& aThreadId);

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void LogComment(const TDesC8& aComment);

	virtual void MediaUpdate(const TDesC8& aMediaSetting,const TBool aForceFlushOn, const TDesC8& aLogPathSetting);

	virtual void ShutDown();

private:

	void WriteDateIntoLog(TBool firstTime);

	CLogManager(MLogArrayAccess& aArrayAccess);

	void ConstructL();

	void ConvertToNarrow(const TDesC& aSource, TDes8& aDestination);

	void DoMediaUpdateL(const TDesC8& aMediaSetting,const TBool aForceFlushOn, const TDesC8& aLogPathSetting);

	void DoStart();

private:

	MLogArrayAccess& iArrayAccess;

	CLoggerMediaBase* iLogger;

	TBuf8<KTimeStringLength> iTimeString;

	TBuf8<KMaxMediaStringLength> iCurrentMediaSetting;

	TUint iTicksSinceLastLog;

	TBool iShutDown;

	TTimeIntervalDays iCurrentDate;			///< store date as # days since 1st Jan 0 AD so we can check when date changes

	TBool iLoggingEnabled;

	TFilePath iLogPath;	// location of output. stored for comparison with next ini files changes

	};

class CLoggerMediaBase : public CBase

	{

public:

	virtual void LogString(const TDesC8& aString) = 0;

	virtual void ClearLogL() = 0;

	virtual void FlushLogL() = 0;

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent) = 0;

	virtual void SetForceFlush(const TBool aOn) = 0;

	TBool iForceBufferFlushAlways;

	};

class CSerialWriter : public CLoggerMediaBase

	{

public:

	~CSerialWriter();

	static CSerialWriter* NewL();

	virtual void LogString(const TDesC8& aString);

	virtual void ClearLogL();

	virtual void FlushLogL();

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void SetForceFlush(const TBool aOn);

	TInt LoadDevices();

	TInt OpenPort(TInt aPortNumber);

	TInt SetPortConfig();

private:

	void ConstructL();

private:

	RBusDevComm iSerialPort;

	RTimer iTimeoutTimer;

	TInt iInvalidCounter;

	};

class CFileWriter : public CLoggerMediaBase

	{

public:

	~CFileWriter();

	static CFileWriter* NewL();

	virtual void LogString(const TDesC8& aString);

	virtual void ClearLogL();

	virtual void FlushLogL();

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void SetForceFlush(const TBool aOn);

	void SetLogPath(const TDesC8& aLogPathSetting);

private:

	void ConstructL();

	void DoFlushBufferToFileL();

	void DoLogBinaryDumpL(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

private:

	RFs iFs;

	HBufC8* iHBuf;

	TBool iForceBufferFlushAlways;

	TFilePath iLogPath;	// We can specifie a path in commsdbg.ini

	TName iLogFileName;	

	};

class CRDebugWriter : public CLoggerMediaBase

	{

public:

	~CRDebugWriter();

	static CRDebugWriter* NewL();

	virtual void LogString(const TDesC8& aString);

	virtual void ClearLogL();

	virtual void FlushLogL();

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void SetForceFlush(const TBool aOn);

	};

class COstv2Writer : public CLoggerMediaBase

	{

public:

	static COstv2Writer* NewL();

	COstv2Writer() : iContext(0x101fe69e, TRACE_STATE) {};

	virtual void LogString(const TDesC8& aString);

	virtual void ClearLogL();

	virtual void FlushLogL();

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void SetForceFlush(const TBool aOn);

private:

	TTraceContext iContext;

	};

#if defined (__WINS__)

class CDebugPortWriter : public CLoggerMediaBase

	{

public:

	static CDebugPortWriter* NewL();

	virtual void LogString(const TDesC8& aString);

	virtual void ClearLogL();

	virtual void FlushLogL();

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void SetForceFlush(const TBool aOn);

private:

	};

class CDebugPortProtocol : public MLogMessageProtocol

	{

public:

	static CDebugPortProtocol* NewL();

	~CDebugPortProtocol();

	virtual void ClearLog(const TFullName& aName);

	virtual void SetTimeL(const TTime& aTime);

	virtual void LogString(const TDesC8& aLogString, const TDesC8& aSubSystem, const TDesC8& aComponent, const TThreadId& aThreadId);

	virtual void LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent);

	virtual void LogComment(const TDesC8& aComment);

	virtual void MediaUpdate(const TDesC8& aMediaSetting, const TBool aForceFlushOn, const TDesC8& aLogPathSetting);

	virtual void ShutDown();

private:

	void ConstructL();

	CDebugPortWriter* iDebugWriter;

	};

#endif

#endif //__COMSDBGWRITER_H__