/*

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

*

*/

#define __DEBUG_THIS__

#include <nsmldebug.h>

#undef __DEBUG_THIS__

#include <f32file.h>

#include <s32file.h>

#include <utf.h>

#include <e32std.h>

#ifdef __WINS__

_LIT( KNSmlDebugOutputName, "C:\\NSmlDebug.txt" );

_LIT( KNSmlDebugDumpName, "C:\\NSmlDebugDump.txt" );

#else

// In emulator logs are written into D: (or E:) drive (easier to read them using PC)

_LIT( KNSmlDebugOutputName, ":\\NSmlDebug.txt" );

_LIT( KNSmlDebugDumpName, ":\\NSmlDebugDump.txt" );

_LIT( KNSmlDebugDriveLetters, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

#endif

_LIT( KNSmlDebugMutexName, "NSmlDebugMutex" );

_LIT( KNSmlDebugMutexNameDump, "NSmlDebugMutexDump" );

static const TInt KBufferSize = 512;

#pragma warning (push)

#pragma warning (disable : 4127)

// --------------------------------------------------------------------------------

// void NSmlGrabMutexLC( RMutex& aMutex, const TDesC& aMutexName )

// --------------------------------------------------------------------------------

LOCAL_C void NSmlGrabMutexLC( RMutex& aMutex, const TDesC& aMutexName )

	{

	while( ETrue )

		{

		TInt ret = aMutex.CreateGlobal(aMutexName);

		if( ret == KErrNone ) // We created the mutex -> Issue wait()

			{

			aMutex.Wait();

			break;

			}

		if( ret == KErrAlreadyExists ) // Mutex already existed -> Open it

			{

			ret = aMutex.OpenGlobal(aMutexName);

			if( ret == KErrNone ) // We got handle to the mutex -> Issue wait()

				{

				aMutex.Wait();

				break;

				}

			}

		}

	CleanupClosePushL(aMutex);

	}

#pragma warning (pop)

// --------------------------------------------------------------------------------

// void DumpToFileL( TPtrC8 aBuffer )

// --------------------------------------------------------------------------------

void DumpToFileL( TPtrC8 aBuffer )

	{

	RFs fileSession;

	TInt pushed(0);

	if( fileSession.Connect() == KErrNone )

		{

		CleanupClosePushL(fileSession);

		pushed++;

		RFile file;

#ifdef __WINS__

		if( file.Open(fileSession, KNSmlDebugOutputName(), EFileShareAny|EFileWrite) == KErrNone )

#else

		HBufC* outputName = HBufC::NewLC( KNSmlDebugOutputName().Length()+1 );

		pushed++;

		TPtr namePtr = outputName->Des();

		TDriveInfo driveInfo;

		for ( TUint driveNumber = EDriveA; driveNumber <= EDriveZ; driveNumber++ ) 

			{

			fileSession.Drive( driveInfo, driveNumber );

			if ( KDriveAttRemovable & driveInfo.iDriveAtt ) 

				{

				// this is MMC

				namePtr.Insert( 0, KNSmlDebugDriveLetters().Mid( driveNumber, 1 ));

				namePtr.Insert( 1, KNSmlDebugOutputName() );

				break;

				}

			}

		if( file.Open(fileSession, *outputName, EFileShareAny|EFileWrite) == KErrNone )

#endif

			{

			CleanupClosePushL(file);

			TInt pos(0);

			file.Seek(ESeekEnd, pos);

			RMutex mutex;

			NSmlGrabMutexLC(mutex, KNSmlDebugMutexName());

			TInt result = file.Write(aBuffer);

			TInt result2 = file.Flush();

			mutex.Signal();

			CleanupStack::PopAndDestroy(2); // file, mutex

			User::LeaveIfError(result);

			User::LeaveIfError(result2);

			}

		CleanupStack::PopAndDestroy( pushed ); // fileSession and (for target) outputName

		}

	}

// --------------------------------------------------------------------------------

// void NSmlGetDateAndTimeL( TDes8& aDateBuffer, TDes8& aTimeBuffer )

// --------------------------------------------------------------------------------

LOCAL_C void NSmlGetDateAndTimeL( TDes8& aDateBuffer, TDes8& aTimeBuffer )

	{

	TTime time;

	time.HomeTime();

	HBufC* dateBuffer = HBufC::NewLC(64);

	TPtr ptrDateBuffer = dateBuffer->Des();

	HBufC* timeBuffer = HBufC::NewLC(64);

	TPtr ptrTimeBuffer = timeBuffer->Des();

	time.FormatL(ptrDateBuffer, _L("%D%M%Y%/0%1%/1%2%/2%3%/3"));

	time.FormatL(ptrTimeBuffer, _L("%-B%:0%J%:1%T%:2%S%.%*C4%:3%+B"));

	CnvUtfConverter::ConvertFromUnicodeToUtf8(aDateBuffer, ptrDateBuffer);

	CnvUtfConverter::ConvertFromUnicodeToUtf8(aTimeBuffer, ptrTimeBuffer);

	CleanupStack::PopAndDestroy(2); // dateBuffer, timeBuffer

	}

// --------------------------------------------------------------------------------

// void doNSmlDebugInitL() - Windows compilation

// --------------------------------------------------------------------------------

#ifdef __WINS__

void doNSmlDebugInitL()

	{

	RFs fileSession;

	User::LeaveIfError(fileSession.Connect());

	CleanupClosePushL(fileSession);

	fileSession.Delete(KNSmlDebugOutputName());

	fileSession.Delete(KNSmlDebugDumpName());	

	RFile file;

#if !defined(__SML_DEVELOPER_DEBUG__)

		{

		User::LeaveIfError(file.Create(fileSession, KNSmlDebugOutputName(), EFileShareAny));

		file.Close();

		}

#endif

		{

		User::LeaveIfError(file.Create(fileSession, KNSmlDebugDumpName(), EFileShareAny));

		file.Close();

		}

	CleanupStack::PopAndDestroy(); // fileSession

	}

// --------------------------------------------------------------------------------

// void doNSmlDebugInitL() - Target compilation

// --------------------------------------------------------------------------------

#else  // #ifdef __WINS__

void doNSmlDebugInitL()

	{

	TInt pushed(0);

	RFs fileSession;

	User::LeaveIfError(fileSession.Connect());

	CleanupClosePushL(fileSession);

	pushed++;

	TDriveInfo driveInfo;

	for ( TUint driveNumber = EDriveA; driveNumber <= EDriveZ; driveNumber++ ) 

		{

		fileSession.Drive( driveInfo, driveNumber );

		if ( KDriveAttRemovable & driveInfo.iDriveAtt ) 

			{

			RFile file;

			HBufC* outputName = HBufC::NewLC( KNSmlDebugOutputName().Length()+1 );

			pushed++;

			TPtr namePtr = outputName->Des();

			namePtr.Insert( 0, KNSmlDebugDriveLetters().Mid( driveNumber, 1 ));

			namePtr.Insert( 1, KNSmlDebugOutputName() );

			HBufC* outputDumpName = HBufC::NewLC( KNSmlDebugDumpName().Length()+1 );

			pushed++;

			TPtr nameDumpPtr = outputDumpName->Des();

			nameDumpPtr.Insert( 0, KNSmlDebugDriveLetters().Mid( driveNumber, 1 ));

			nameDumpPtr.Insert( 1, KNSmlDebugDumpName() );

			fileSession.Delete(*outputName);

			fileSession.Delete(*outputDumpName);	

#if !defined(__SML_DEVELOPER_DEBUG__)

				{

				User::LeaveIfError(file.Create(fileSession, *outputName, EFileShareAny));

				file.Close();

				}

#endif

				{

				User::LeaveIfError(file.Create(fileSession, *outputDumpName, EFileShareAny));

				file.Close();

				break;

				}

			}

		}

	CleanupStack::PopAndDestroy( pushed ); // fileSession

	}

#endif

// --------------------------------------------------------------------------------

// void NSmlDebugInitL()

// --------------------------------------------------------------------------------

EXPORT_C void NSmlDebugInitL()

	{

	TInt err(KErrNone);

	TRAP(err, doNSmlDebugInitL());

	}

// --------------------------------------------------------------------------------

// void doNSmlDebugPrintL( TInt aCode, const TText8* aMsg, TBool aPrintToFile, TText8* aFile, TInt aLine )

// --------------------------------------------------------------------------------

void doNSmlDebugPrintL( TInt aCode, const TText8* aMsg, TBool aPrintToFile, TText8* aFile, TInt aLine )

	{

	HBufC8* dateBuffer8 = HBufC8::NewLC(64);

	TPtr8 ptrDateBuffer8 = dateBuffer8->Des();

	HBufC8* timeBuffer8 = HBufC8::NewLC(64);

	TPtr8 ptrTimeBuffer8 = timeBuffer8->Des();

	NSmlGetDateAndTimeL(ptrDateBuffer8, ptrTimeBuffer8);

	TPtrC8 fileName(aFile);

	HBufC8* buffer8 = HBufC8::NewLC(KBufferSize);

	TPtr8 ptrBuffer8 = buffer8->Des();

	TPtrC8 msg(aMsg);

#if !defined(__SML_DEVELOPER_DEBUG__)

	ptrBuffer8.Format(_L8("[%S File: %S Line: %d] %S [Code: %d]\r\n"), &ptrTimeBuffer8, &fileName, aLine, &msg, aCode);

#else

	ptrBuffer8.Format(_L8("[%S] %S\r\n"), &ptrTimeBuffer8, &msg);

#endif

	if( aPrintToFile )

		{

		DumpToFileL(ptrBuffer8);

		}

	else

		{

		HBufC* buffer = HBufC::NewLC(KBufferSize);

		TPtr ptrBuffer = buffer->Des();

		CnvUtfConverter::ConvertToUnicodeFromUtf8(ptrBuffer, ptrBuffer8);

		User::InfoPrint(ptrBuffer);

		CleanupStack::PopAndDestroy(); // buffer

		}

	CleanupStack::PopAndDestroy(3); // buffer8, dateBuffer8, timeBuffer8

	}

// --------------------------------------------------------------------------------

// void NSmlDebugPrintL( const TText8* aMsg, TBool aPrintToFile, TText8* aFile, TInt aLine )

// --------------------------------------------------------------------------------

EXPORT_C void NSmlDebugPrintL( const TText8* aMsg, TBool aPrintToFile, TText8* aFile, TInt aLine )

	{

	TInt err(KErrNone);

	TRAP(err, doNSmlDebugPrintL( 0, aMsg, aPrintToFile, aFile, aLine));

	}

// --------------------------------------------------------------------------------

// void NSmlDebugPrint_CodeL( TInt aCode, const TText8* aMsg, TBool aPrintToFile, TText8* aFile, TInt aLine )

// --------------------------------------------------------------------------------

EXPORT_C void NSmlDebugPrint_CodeL( TInt aCode, const TText8* aMsg, TBool aPrintToFile, TText8* aFile, TInt aLine )

	{

	TInt err(KErrNone);

	TRAP(err, doNSmlDebugPrintL(aCode, aMsg, aPrintToFile, aFile, aLine));

	}

// --------------------------------------------------------------------------------

// void doNSmlDebugDumpL( void* aData, TInt aLength, TText8* aFile, TInt aLine, const TText8* aMsg )

// --------------------------------------------------------------------------------

void doNSmlDebugDumpL( void* aData, TInt aLength, TText8* aFile, TInt aLine, const TText8* aMsg )

	{

	TInt pushed(0);

	HBufC8* pDateBuffer8 = HBufC8::NewLC(64);

	pushed++;

	TPtr8 dateBuffer8 = pDateBuffer8->Des();

	HBufC8* pTimeBuffer8 = HBufC8::NewLC(64);

	pushed++;

	TPtr8 timeBuffer8 = pTimeBuffer8->Des();

	NSmlGetDateAndTimeL(dateBuffer8, timeBuffer8);

	TPtrC8 data(REINTERPRET_CAST(TUint8*, aData), aLength);

	TPtrC8 fileName(aFile);

	HBufC8* buffer8 = HBufC8::NewLC(KBufferSize);

	pushed++;

	TPtr8 ptrBuffer8 = buffer8->Des();

	TPtrC8 msg(aMsg);

	if( !msg.Length() )

		{

#if !defined(__SML_DEVELOPER_DEBUG__)

		ptrBuffer8.Format(_L8("[%S %S File: %S Line: %d Length: %d]\r\n"), &dateBuffer8, &timeBuffer8, &fileName, aLine, aLength);

#else

		ptrBuffer8.Format(_L8("[%S %S Length: %d]\r\n"), &dateBuffer8, &timeBuffer8, aLength);

#endif

		}

	else

		{

#if !defined(__SML_DEVELOPER_DEBUG__)

		ptrBuffer8.Format(_L8("[%S %S File: %S Line: %d Length: %d] %S\r\n"), &dateBuffer8, &timeBuffer8, &fileName, aLine, aLength, &msg);

#else

		ptrBuffer8.Format(_L8("[%S %S Length: %d] %S\r\n"), &dateBuffer8, &timeBuffer8, aLength, &msg);

#endif

		}

	// Now we're ready to write into file

	RFs fileSession;

	if( fileSession.Connect() == KErrNone )

		{

		CleanupClosePushL(fileSession);

		pushed++;

		RFile file;

#ifdef __WINS__

		if( file.Open(fileSession, KNSmlDebugDumpName(), EFileShareAny|EFileWrite) == KErrNone )

#else

		HBufC* outputDumpName = HBufC::NewLC( KNSmlDebugDumpName().Length()+1 );

		pushed++;

		TPtr nameDumpPtr = outputDumpName->Des();

		TDriveInfo driveInfo;

		for ( TUint driveNumber = EDriveA; driveNumber <= EDriveZ; driveNumber++ ) 

			{

			fileSession.Drive( driveInfo, driveNumber );

			if ( KDriveAttRemovable & driveInfo.iDriveAtt ) 

				{

				// this is MMC

				nameDumpPtr.Insert( 0, KNSmlDebugDriveLetters().Mid( driveNumber, 1 ));

				nameDumpPtr.Insert( 1, KNSmlDebugDumpName() );

				break;

				}

			}

		if( file.Open(fileSession, *outputDumpName, EFileShareAny|EFileWrite) == KErrNone )

#endif

			{

			CleanupClosePushL(file);

			TInt pos(0);

			file.Seek(ESeekEnd, pos);

			RMutex mutex;

			NSmlGrabMutexLC(mutex, KNSmlDebugMutexNameDump());

			TInt result1 = file.Write(ptrBuffer8);

			TInt result2 = file.Write(data);

			TInt result3 = file.Write(_L8("\r\n\r\n"));

			TInt result4 = file.Flush();

			mutex.Signal();

			CleanupStack::PopAndDestroy(2); // file, mutex

			User::LeaveIfError(result1);

			User::LeaveIfError(result2);

			User::LeaveIfError(result3);

			User::LeaveIfError(result4);

			}

		}

	CleanupStack::PopAndDestroy( pushed ); // buffer8, pDateBuffer8, pTimeBuffer8

	}

// --------------------------------------------------------------------------------

// void NSmlDebugDumpL( void* aData, TInt aLength, TText8* aFile, TInt aLine, const TText8* aMsg )

// --------------------------------------------------------------------------------

EXPORT_C void NSmlDebugDumpL( void* aData, TInt aLength, TText8* aFile, TInt aLine, const TText8* aMsg )

	{

	TInt err(KErrNone);

	TRAP(err, doNSmlDebugDumpL(aData, aLength, aFile, aLine, aMsg));

	}

// --------------------------------------------------------------------------------

// void NSmlDebugPrintHeaderL( TText8* aFile, TInt aLine )

// --------------------------------------------------------------------------------

void _NSmlDebugPrintHeaderL( TText8* aFile, TInt aLine )

	{

	HBufC8* pDateBuffer8 = HBufC8::NewLC(64);

	TPtr8 dateBuffer8 = pDateBuffer8->Des();

	HBufC8* pTimeBuffer8 = HBufC8::NewLC(64);

	TPtr8 timeBuffer8 = pTimeBuffer8->Des();

	NSmlGetDateAndTimeL(dateBuffer8, timeBuffer8);

	TPtrC8 fileName(aFile);

	HBufC8* buffer8 = HBufC8::NewLC(KBufferSize);

	TPtr8 ptrBuffer8 = buffer8->Des();

#if !defined(__SML_DEVELOPER_DEBUG__)

	ptrBuffer8.Format(_L8("[%S File: %S Line: %d]"), &timeBuffer8, &fileName, aLine);

#else

	ptrBuffer8.Format(_L8("[%S]"), &timeBuffer8);

#endif

	ptrBuffer8.Append(_L8(" "));

	DumpToFileL(ptrBuffer8);

	CleanupStack::PopAndDestroy(3); // buffer8, pDateBuffer, pTimeBuffer

	}

EXPORT_C void NSmlDebugPrintHeaderL( TText8* aFile, TInt aLine )

	{

	TInt err(KErrNone);

	TRAP(err, _NSmlDebugPrintHeaderL(aFile, aLine));

	}

// --------------------------------------------------------------------------------

// void NSmlDebugPrintArgs8L( TText8* aFmt, ... )

// --------------------------------------------------------------------------------

void _NSmlDebugPrintArgs8L( const TDesC8& aFmt, VA_LIST aList )

	{

	HBufC8* pBuf = HBufC8::NewLC(1024*2);

	TPtr8 buf = pBuf->Des();

	buf.FormatList(aFmt, aList);

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

	DumpToFileL(buf);

	CleanupStack::PopAndDestroy(); // pBuf

	}

EXPORT_C void NSmlDebugPrintArgs8L( const TText8* aFmt, ... )

	{

	VA_LIST args;

	VA_START (args, aFmt);

	TInt err(KErrNone);

	TRAP(err, _NSmlDebugPrintArgs8L(TPtrC8(aFmt), args));

	VA_END(args);

	}

// --------------------------------------------------------------------------------

// void NSmlDebugPrintArgs16L( TText8* aFmt, ... )

// --------------------------------------------------------------------------------

void _NSmlDebugPrintArgs16L( const TDesC16& aFmt, VA_LIST aList )

	{

	HBufC16* buf = HBufC16::NewLC(1024*2);

	buf->Des().FormatList(aFmt, aList);

	HBufC8* pBuf8 = HBufC8::NewLC(1024*2);

	TPtr8 buf8 = pBuf8->Des();

	buf8.Copy(*buf);

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

	DumpToFileL(buf8);

	CleanupStack::PopAndDestroy(2); // buf, bBuf8

	}

EXPORT_C void NSmlDebugPrintArgs16L( const TText16* aFmt, ... )

	{

	VA_LIST args;

	VA_START (args, aFmt);

	TInt err(KErrNone);

	TRAP(err, _NSmlDebugPrintArgs16L(TPtrC16(aFmt), args));

	VA_END(args);

	}

//End of File