/*

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

* Logging engine for USB.

*

*/

/**

 @file

 @internalTechnology

*/

#include <e32base.h>

#include <comms-infras/commsdebugutility.h>

#include <usb/usblogger.h>

#ifdef __USB_DEBUG_RDEBUG__

#include <e32debug.h>

const TInt KUSBLogBufferSize=255;

class TUSBFlogOverflow8  : public TDes8Overflow

     {

public:

     void Overflow(TDes8& /*aDes*/) { }

     };

class TUSBFlogOverflow16  : public TDes16Overflow

     {

public:

     void Overflow(TDes16& /*aDes*/) { }

     };

void __CUsbLog_DoHexDump(const TDesC8& aCmpt, const TDesC8& aData, const TDesC8& aHeader, const TDesC8& aMargin);

#endif //__USB_DEBUG_RDEBUG__

#ifdef __FLOG_ACTIVE

_LIT8(KSubsystem, "USB");

_LIT8(KLogCmpt, "logengine");

#endif

NONSHARABLE_CLASS(TLogData)

	{

	public:

#ifdef __FLOG_ACTIVE

		TLogData();

		void SetLogTags(const TDesC8& aCmpt);

		TInt iAccessCount;

		RFileLogger iLogEngine;

		TBuf8<KMaxTagLength> iCurrentComponent;

#endif

	};

#ifdef __FLOG_ACTIVE

TLogData::TLogData()

	: iAccessCount(0), iCurrentComponent(KNullDesC8)

	{}

void TLogData::SetLogTags(const TDesC8& aCmpt)

	{

	if (aCmpt != iCurrentComponent)

		{

		iLogEngine.SetLogTags(KSubsystem, aCmpt.Left(KMaxTagLength));

		iCurrentComponent = aCmpt.Left(KMaxTagLength);

		}

	}

#endif

#define GETLOG TLogData* __logger = static_cast<TLogData*>(Dll::Tls());

EXPORT_C /*static*/ TInt CUsbLog::Connect()

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

	if (!__logger)

		{

		CUsbLog::Write(KLogCmpt, _L8("Opening new logger connection"));

		__logger = new TLogData();

		if (!__logger)

			{

			CUsbLog::Write(KLogCmpt, _L8("Opening logger connection failed, no memory"));

			return KErrNoMemory;

			}

		__logger->iLogEngine.Connect();

		Dll::SetTls(__logger);

		}

	__logger->iAccessCount++;

	CUsbLog::WriteFormat(KLogCmpt, _L8("Opening -- %d instances now open"), __logger->iAccessCount);

	return KErrNone;

#else

	return KErrNotSupported;

#endif

	}

EXPORT_C /*static*/ void CUsbLog::Close()

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

	if (__logger)

		{

		TInt& count = __logger->iAccessCount;

		if (count)

			{

			count--;

			CUsbLog::WriteFormat(KLogCmpt, _L8("Closing -- %d instance(s) left open"), count);

			if (!count)

				{

				__logger->iLogEngine.Close();

				delete __logger;

				Dll::SetTls(NULL);

				CUsbLog::Write(KLogCmpt, _L8("Fully closed and deleted, now flogging statically."));

				}

			}

		else

			{

			CUsbLog::Write(KLogCmpt, _L8("Not closing -- not opened"));

			}

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::Write(const TDesC8& IF_FLOGGING(aCmpt), const TDesC8& IF_FLOGGING(aText))

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

		TBuf8<KUSBLogBufferSize> buf;

		RThread thread;

		buf.AppendFormat(_L8("%S\t%S\t%LX\t%S\r\n"), &KSubsystem(), &aCmpt, thread.Id().Id(), &aText);

		RDebug::RawPrint(buf);

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.Write(aText);

		}

	else

		{

		RFileLogger::Write(KSubsystem, aCmpt, aText);

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::WriteFormat(const TDesC8& IF_FLOGGING(aCmpt), TRefByValue<const TDesC8> IF_FLOGGING(aFmt), ...)

	{

#ifdef __FLOG_ACTIVE

	VA_LIST list;

	VA_START(list, aFmt);

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

		TUSBFlogOverflow8 objFlogBody8;

		TBuf8<KUSBLogBufferSize> buf;

		RThread thread;

		buf.AppendFormat(_L8("%S\t%S\t%LX\t"), &KSubsystem(), &aCmpt, thread.Id().Id());

		buf.AppendFormatList(aFmt, list, &objFlogBody8);

		buf.Append(_L8("\r\n"));

		RDebug::RawPrint(buf);

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.WriteFormat(aFmt, list);

		}

	else

		{

		RFileLogger::WriteFormat(KSubsystem, aCmpt, aFmt, list);

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::WriteFormat(const TDesC8& IF_FLOGGING(aCmpt), TRefByValue<const TDesC8> IF_FLOGGING(aFmt), VA_LIST& IF_FLOGGING(aList))

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

		TUSBFlogOverflow8 objFlogBody8;

		TBuf8<KUSBLogBufferSize> buf;

		RThread thread;

		buf.AppendFormat(_L8("%S\t%S\t%LX\t"), &KSubsystem(), &aCmpt, thread.Id().Id());

		buf.AppendFormatList(aFmt, aList, &objFlogBody8);

		buf.Append(_L8("\r\n"));

		RDebug::RawPrint(buf);

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.WriteFormat(aFmt, aList);

		}

	else

		{

		RFileLogger::WriteFormat(KSubsystem, aCmpt, aFmt, aList);

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::Write(const TDesC8& IF_FLOGGING(aCmpt), const TDesC16& IF_FLOGGING(aText))

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

		TBuf16<KUSBLogBufferSize> buf;

		buf.AppendFormat(_L16("(TDesC16): %S\r\n"), &aText);

		RDebug::RawPrint(buf);

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.Write(aText);

		}

	else

		{

		RFileLogger::WriteFormat(KSubsystem, aCmpt, aText);

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::WriteFormat(const TDesC8& IF_FLOGGING(aCmpt), TRefByValue<const TDesC16> IF_FLOGGING(aFmt), ...)

	{

#ifdef __FLOG_ACTIVE

	VA_LIST list;

	VA_START(list, aFmt);

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

		TUSBFlogOverflow16 objFlogBody16;

		TBuf16<KUSBLogBufferSize> wideBuf;

		wideBuf.Append(_L16("(TDesC16): "));

		wideBuf.AppendFormatList(aFmt, list, &objFlogBody16);

		wideBuf.Append(_L16("\r\n"));

		RDebug::RawPrint(wideBuf);

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.WriteFormat(aFmt, list);

		}

	else

		{

		RFileLogger::WriteFormat(KSubsystem, aCmpt, aFmt, list);

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::WriteFormat(const TDesC8& IF_FLOGGING(aCmpt), TRefByValue<const TDesC16> IF_FLOGGING(aFmt), VA_LIST& IF_FLOGGING(aList))

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

		TUSBFlogOverflow16 objFlogBody16;

		TBuf16<KUSBLogBufferSize> wideBuf;

		wideBuf.Append(_L16("(TDesC16): "));

		wideBuf.AppendFormatList(aFmt, aList, &objFlogBody16);

		wideBuf.Append(_L16("\r\n"));

		RDebug::RawPrint(wideBuf);

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.WriteFormat(aFmt, aList);

		}

	else

		{

		RFileLogger::WriteFormat(KSubsystem, aCmpt, aFmt, aList);

		}

#endif

	}

EXPORT_C /*static*/ void CUsbLog::HexDump(const TDesC8& IF_FLOGGING(aCmpt), const TText* IF_FLOGGING(aHeader), const TText* IF_FLOGGING(aMargin), const TUint8* IF_FLOGGING(aPtr), TInt IF_FLOGGING(aLen))

	{

#ifdef __FLOG_ACTIVE

	GETLOG;

#ifdef __USB_DEBUG_RDEBUG__

	__CUsbLog_DoHexDump(aCmpt, TPtrC8(aPtr, aLen), TPtrC8(NULL,0), TPtrC8(NULL,0));

#endif // __USB_DEBUG_RDEBUG

	if (__logger)

		{

		__logger->SetLogTags(aCmpt);

		__logger->iLogEngine.HexDump(aHeader, aMargin, aPtr, aLen);

		}

	else

		{

		RFileLogger::HexDump(KSubsystem, aCmpt, TPtrC8(aPtr, aLen), KNullDesC8);

		}

#endif

	}

#ifdef __USB_DEBUG_RDEBUG__

#define BLANK	_S("")

const TInt KHexDumpWidth=16;			///< Number of bytes written per line when formatting as hex.

const TInt KLowestPrintableCharacter = 32; ///< In Hex output, replace chars below space with a dot.

const TInt KHighestPrintableCharacter = 126; ///< In Hex output, replace chars above 7-bits with a dot.

_LIT8(KFirstFormatString8,"%04x : ");   ///< Format string used in Hexdump to format first part: header and byte numbers.

_LIT8(KSecondFormatString8,"%02x ");      ///< Format string used in Hexdump to format mid part: each of the 16 bytes as hex

_LIT8(KThirdFormatString8,"%c");          ///< Format string used in Hexdump to format the last part: each of the 16 bytes as characters

_LIT8(KThreeSpaces8,"   ");               ///< Format string used in Hexdump to define padding between first and mid parts

_LIT8(KTwoSpaces8," ");                   ///< Format string used in Hexdump to define padding between hex and char bytes.

const TText8 KFullStopChar8='.';

void __CUsbLog_DoHexDump(const TDesC8& aCmpt, const TDesC8& aData, const TDesC8& aHeader, const TDesC8& aMargin)

	{

#ifdef __FLOG_ACTIVE

	HBufC8* marginStr = NULL;

	TBuf8<KMaxHexDumpWidth> buf;

	TInt aRemainingLen = aData.Length();

	TInt aHeaderLen = aHeader.Length();

	TUSBFlogOverflow8 objFlogBody8;

	if (aData.Length()==0)		// nothing to do

		{

		return;

		}

	if (aHeaderLen > 0)

		{

		if (aMargin.Length() == 0)

			{

			marginStr = HBufC8::New(aHeader.Length());

			if (marginStr == NULL)

				{

				return;		// abort if No memory

				}

			TPtr8 marginStrPtr(marginStr->Des());

			marginStrPtr.AppendFill(' ',aHeader.Length());

			}

		else

			{

			marginStr = aMargin.Alloc();

			}

		}

	TUint blockStartPos = 0;

	while (aRemainingLen>0)

		{

		RThread thread;

		buf.AppendFormat(_L8("%S\t%S\t%LX\t"), &KSubsystem(), &aCmpt, thread.Id().Id());

		TInt blockLength = (aRemainingLen>KHexDumpWidth ? KHexDumpWidth : aRemainingLen);

		// write the header/margin and print in hex which bytes we are about to write

		if (blockStartPos == 0)

			{

			if (aHeaderLen > 0)

				{

				buf.Append(aHeader);

				}

			buf.AppendFormat(KFirstFormatString8,&objFlogBody8, blockStartPos);

			}

		else

			{

			if (marginStr)

				{

				buf.Append(*marginStr);

				}

			buf.AppendFormat(KFirstFormatString8,&objFlogBody8,blockStartPos);

			}

		TInt bytePos;

		// write the bytes as hex

		for (bytePos = 0; bytePos < blockLength; bytePos++)

			{

			buf.AppendFormat(KSecondFormatString8,aData[blockStartPos + bytePos]);

			}

		while (bytePos++ < KHexDumpWidth)

			{

			buf.Append(KThreeSpaces8);

			}

		buf.Append(KTwoSpaces8);

		// print the bytes as characters, or full stops if outside printable range

		for (bytePos = 0; bytePos < blockLength; bytePos++)

			{

			buf.AppendFormat(KThirdFormatString8,(aData[blockStartPos + bytePos] < KLowestPrintableCharacter || aData[blockStartPos + bytePos] > KHighestPrintableCharacter) ? KFullStopChar8 : aData[blockStartPos + bytePos]);

			}

		buf.Append(_L8("\r\n"));

		RDebug::RawPrint(buf);

		buf.SetLength(0);

		aRemainingLen -= blockLength;

		blockStartPos += blockLength;

		}

	delete marginStr;

#endif // __FLOG_ACTIVE

	}

#endif // __USB_DEBUG_RDEBUG

/**

Leave (if error) verbosely- log name of file and line number just before

leaving.

@param aFile The file we're leaving from.

@param aLine The line number we're leaving from.

@param aReason The leave code.

*/

EXPORT_C void VerboseLeaveIfErrorL(const TDesC8& IF_FLOGGING(aCpt),

						  char* IF_FLOGGING(aFile),

						  TInt IF_FLOGGING(aLine),

						  TInt aReason)

	{

	// only leave negative value

	if ( aReason >= 0 )

		{

		return;

		}

#ifdef __FLOG_ACTIVE

	_LIT8(KLeavePrefix, "LEAVE: ");

	TPtrC8 fullFileName((const TUint8*)aFile);

	TPtrC8 fileName(fullFileName.Ptr()+fullFileName.LocateReverse('\\')+1);

	TBuf8<256> buf;

	buf.Append(KLeavePrefix);

	buf.AppendFormat(_L8("aReason = %d [file %S, line %d]"), aReason, &fileName,

		aLine);

	CUsbLog::Write(aCpt, buf);

#endif

	// finally

	User::Leave(aReason);

	}

/**

Leave verbosely- log name of file and line number just before

leaving.

@param aFile The file we're leaving from.

@param aLine The line number we're leaving from.

@param aReason The leave code.

*/

EXPORT_C void VerboseLeaveL(const TDesC8& IF_FLOGGING(aCpt),

						  char* IF_FLOGGING(aFile),

						  TInt IF_FLOGGING(aLine),

						  TInt aReason)

	{

#ifdef __FLOG_ACTIVE

	_LIT8(KLeavePrefix, "LEAVE: ");

	TPtrC8 fullFileName((const TUint8*)aFile);

	TPtrC8 fileName(fullFileName.Ptr()+fullFileName.LocateReverse('\\')+1);

	TBuf8<256> buf;

	buf.Append(KLeavePrefix);

	buf.AppendFormat(_L8("aReason = %d [file %S, line %d]"), aReason, &fileName,

		aLine);

	CUsbLog::Write(aCpt, buf);

#endif

	// finally

	User::Leave(aReason);

	}

/**

Panic verbosely- log name of file and line number just before panicking.

@param aFile The file that's panicking.

@param aLine The line number that's panicking.

@param aReason The panic code.

@param aPanicName The text of the panic code.

@param aPanicCategory The panic category.

*/

EXPORT_C void VerbosePanic(const TDesC8& IF_FLOGGING(aCpt),

				  char* IF_FLOGGING(aFile),

				  TInt IF_FLOGGING(aLine),

				  TInt aPanicCode,

				  TText8* IF_FLOGGING(aPanicName),

				  const TDesC& aPanicCategory)

	{

#ifdef __FLOG_ACTIVE

	_LIT8(KPanicPrefix, "PANIC: code ");

	TPtrC8 fullFileName((const TUint8*)aFile);