// 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:

// Implements the Flogger server side data writing

// 

//

/**

 @file

 @internalComponent

*/

#include "comsdbgwriter.h"

#include "comsdbgmessages.h"

const TInt KHeapBufSize = 50000;   // Maximum that the file buffer can grow to limit its impact somewhat

// RDebug will truncate strings longer than the limit below

const TInt KRDebugLimit = 0x100;

// source strings, lengths and offsets

_LIT8(KLogStartedString, "#Logging started on dd/mm/yyyy. Output version 2\r\n");	///< Format specifier for the very first line written. The output version is printed so tools processing the log output can determine the expected format of the output.

_LIT8(KDateChangedString,"#      Date is now: dd/mm/yyyy.\r\n");	///< Format specifier for subsequent date changes

const TInt KLogStartedStringLength = 50;

const TInt KLogStartedDayOffset = 20;

const TInt KLogStartedMonthOffset = 23;

const TInt KLogStartedYearOffset = 26;

_LIT8(KUnableToLog, "#Logs lost since log file couldn't be written to");

_LIT8(KClearLogString, "#Clear Log called by ");

const TInt KClearLogStringLength = 21;

_LIT8(KEolCharacters, "\r\n");

const TInt KEolCharactersLength = 2;

_LIT8(KLogPathTree,"\\");	

_LIT8(KLogFileExt,".");

//Below const is... log string + 2 tags + 8 for the thread id + 3 tabs + EOL characters.

const TInt KMaxFinalLogStringLength = KLogBufferSize+2*KMaxTagLength+8+3+KEolCharactersLength;

_LIT8(KBadMediaString, "#Bad media setting in ini file.\r\n");

_LIT8(KUnableToUpdateMedia, "#Unable to update logging media. Err code: %d\r\n");

_LIT8(KUnableToLoadSerialDevices, "#Unable to load the LDD or PDD required for serial. Err code: %d\r\n");

_LIT8(KUnableToOpenSerial, "#Unable to open the serial port. Err code: %d\r\n");

_LIT8(KUnableToSetSerialConfig, "#Could not set serial port configuration after opening port. Err code: %d\r\n");

// source characters

_LIT8(KTabCharacter, "\t");

_LIT8(KTypeIdentifierAscii, "a");

_LIT8(KTypeIdentifierBinary, "b");

// serial specs

const TBps KFloggerSerialRate = EBps115200;

const TInt KSerialRetryCount = 50;

const TInt KSerialTimeoutInMicroSecs = 100000;

// serial ports

const TInt KSerialPort1 = 0;

#if defined (__WINS__)

const TInt KSerialPort2OnEmulator = 1;

#else

const TInt KSerialPort2OnTarget = 2;

#endif

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV.PDD")

#define LDD_NAME _L("ECOMM.LDD")

#else

#define PDD_NAME _L("EUART1")

#define LDD_NAME _L("ECOMM")

#endif

// log file specs

_LIT(KLogFileName, "log.txt");

_LIT(KLogDefaultFilePath, "C:\\logs\\");

const TUint KZeroDate = 0;  ///< The day to count forward from when determining date roll.

const TUint KSecondsToWriteTimestampOnNoActivity = 5;

#if defined (__WINS__)

const TInt Win32DisplayStringLengthMax = 1024; 

#endif

CLogManager* CLogManager::NewL(MLogArrayAccess& aArrayAccess)

	{

	CLogManager* self = new(ELeave) CLogManager(aArrayAccess);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CLogManager::CLogManager(MLogArrayAccess& aArrayAccess)

: iArrayAccess(aArrayAccess), iTimeString(KTimeFormat)

{}

CLogManager::~CLogManager()

	{

	delete iLogger;

	}

void CLogManager::ConstructL()

/*

 * Set the initial media to file and write there until the server has told us

 * which media is in the ini file.

 * Write the log started and date message. 

 */

	{

	iLogger = CFileWriter::NewL();	//File writer by default

	iCurrentMediaSetting = KFileMedia;

	iLoggingEnabled = EFalse;

	}

TInt CLogManager::ThreadEntryPoint(TAny* aPtr)

	{

	MLogArrayAccess* arrayAccess = static_cast<MLogArrayAccess*> (aPtr);

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if (cleanupStack==NULL)

		{

		return KErrNoMemory;

		}

	TRAPD(err, CLogManager::DoRunThreadL(*arrayAccess));

	delete cleanupStack;

	return err;

	}

void CLogManager::DoRunThreadL(MLogArrayAccess& aArrayAccess)

	{

	CLogManager* self = CLogManager::NewL(aArrayAccess);

	self->DoStart();

	delete self;

	}

void CLogManager::DoStart()

/**

 * Second/consumer/slave/draining/dequeuer thread main loop.

 * @note Continuously takes the log queue top message and processes it. Blocks on the "Get" if no messages.

 * @note Completes when a shutdown message is processed from the queue. This message sets "iShutDown".

 */

	{

	CLogMessageBase * message = NULL;

	TInt ret = KErrNone;

	RThread::Rendezvous(ret);

	FOREVER

		{

		iArrayAccess.GetFirstMessageAndTakeOwnership(message);

		__ASSERT_ALWAYS(message, User::Panic(KFloggerServerPanic, ENullMessageInArray));

		message->Invoke(*this);

		delete message;

        // GetFirstMessage waits on the request semaphore, so to balance these each 

		// time a message is processed we must then signal the completion semaphore

		// when in synchronous mode

		iArrayAccess.SignalCompletionSemaphore();

		if (iShutDown)

			{

			break;

			}

		}

	}

void CLogManager::WriteDateIntoLog(TBool firstTime)

/**

 * Write the date straight to the log output

 * @param firstTime If ETrue then write a "log started" otherwise write a "date change" msg

 */

	{

	if (!iLoggingEnabled) 

	   {

	   return;

	   }

	//Put a date stamp for when we've started logging

	//Can't use TTime::FormatL since it gives unicode and we want narrow.

	TTime time;

	TBuf8<KLogStartedStringLength> logDateString;

	time.HomeTime();

	TDateTime dateTime(time.DateTime());

	if (firstTime)

		{

		logDateString.Copy(KLogStartedString);

		}

	else

		{

		logDateString.Copy(KDateChangedString);

		}

	TBuf8<2> holdingBuf;

	holdingBuf.NumFixedWidth(dateTime.Day()+1, EDecimal, 2);

	logDateString.Replace(KLogStartedDayOffset,2,holdingBuf);

	holdingBuf.NumFixedWidth(dateTime.Month()+1, EDecimal, 2);

	logDateString.Replace(KLogStartedMonthOffset,2,holdingBuf);

	TBuf8<4> holdingBuf2;

	holdingBuf2.NumFixedWidth(dateTime.Year(), EDecimal, 4);

	logDateString.Replace(KLogStartedYearOffset,4,holdingBuf2);

	iLogger->LogString(logDateString);

	}

void CLogManager::ClearLog(const TFullName& aName)

	{

	if (!iLoggingEnabled) 

	   {

	   return;

	   }

	TRAP_IGNORE(iLogger->ClearLogL());	//if there is an error there is nothing we can do.

	TBuf8<KMaxFullName+KClearLogStringLength+KEolCharactersLength> buf(KClearLogString);

	buf.Append(aName);

	buf.Append(KEolCharacters);

	iLogger->LogString(buf);

	WriteDateIntoLog(ETrue);

	iTicksSinceLastLog=0;

	}

void CLogManager::SetTimeL(const TTime& aTime)

	{

	if (!iLoggingEnabled) 

	   {

	   return;

	   }

	//check whether date has rolled and write it to log if necessary

	TTime currentMicrosecs;

	TTimeIntervalDays newDate;

	currentMicrosecs.HomeTime();

	TTime zeroDate = TTime(TInt64(KZeroDate));

	newDate = currentMicrosecs.DaysFrom(zeroDate);

	if (newDate > iCurrentDate)

		{

		WriteDateIntoLog(EFalse);

		iCurrentDate = newDate;

		}

	//Print the time to the log

	//Have to do this stuff manually since TTime only provides Unicode formating

	//which is not what we want.

	// We format this each second regardless of whether it is used so that it is ready for use

	// if a client logs since in normal use it would be rare for flogger not to log something each second.

	TDateTime dateTime(aTime.DateTime());

	TBuf8<2> holdingBuf;

	holdingBuf.NumFixedWidth(dateTime.Hour(), EDecimal, 2);

	iTimeString.Replace(KHourOffset,2,holdingBuf);

	holdingBuf.NumFixedWidth(dateTime.Minute(), EDecimal, 2);

	iTimeString.Replace(KMinuteOffset,2,holdingBuf);

	holdingBuf.NumFixedWidth(dateTime.Second(), EDecimal, 2);

	iTimeString.Replace(KSecondOffset,2,holdingBuf);

	if (iTicksSinceLastLog++ < KSecondsToWriteTimestampOnNoActivity)

		{

		iLogger->LogString(iTimeString);

		iLogger->FlushLogL();

		}

	}

void CLogManager::LogString(const TDesC8& aLogString, const TDesC8& aSubSystem, const TDesC8& aComponent, const TThreadId& aThreadId)

	{

	if (!iLoggingEnabled) 

	   {

	   return;

	   }

	if (iTicksSinceLastLog > KSecondsToWriteTimestampOnNoActivity)

		{

		iLogger->LogString(iTimeString);

		}

	iTicksSinceLastLog=0;

	TBuf8<KMaxFinalLogStringLength> buf;

	buf.Append(aSubSystem);

	buf.Append(KTabCharacter);

	buf.Append(aComponent);

	buf.Append(KTabCharacter);

	buf.Append(KTypeIdentifierAscii);

	buf.Append(KTabCharacter);

	buf.AppendNum(aThreadId, EHex);

	buf.Append(KTabCharacter);

	buf.Append(aLogString);

	// check whether last two bytes of string are eol chars, since some lines have cr/lf, some don't

	TPtr8 ptr(&buf[buf.Length()-2], 2, 2);

	if (ptr.Compare(KEolCharacters)!=0)

		{

		buf.Append(KEolCharacters);

		}

	iLogger->LogString(buf);

	}

void CLogManager::LogBinaryDump(const TDesC8& aBinaryString, const TDesC8& aSubSystem, const TDesC8& aComponent)

	{

	iLogger->LogBinaryDump(aBinaryString, aSubSystem, aComponent);

	}

void CLogManager::LogComment(const TDesC8& aComment)

	{

	if (iTicksSinceLastLog > KSecondsToWriteTimestampOnNoActivity)

		{

		iLogger->LogString(iTimeString);

		}

	iTicksSinceLastLog=0;

	iLogger->LogString(aComment);

	}

void CLogManager::MediaUpdate(const TDesC8& aMediaSetting, const TBool aForceFlush, const TDesC8& aLogPathSetting)

	{

	TRAPD(err, DoMediaUpdateL(aMediaSetting,aForceFlush, aLogPathSetting));

	if (err!=KErrNone)

		{

		TBuf8<KMaxFinalLogStringLength> buf;

		buf.Format(KUnableToUpdateMedia,err);

		iLogger->LogString(buf);

		}

	}

void CLogManager::DoMediaUpdateL(const TDesC8& aMediaSetting,const TBool aForceFlush, const TDesC8& aLogPathSetting)

	{

	//We should NEVER have no media selected, media is set on construction

	//and there should always be something set up.

	__ASSERT_ALWAYS(iLogger, User::Panic(KFloggerServerPanic, ENoLoggingMediaSetUp));

	if (aMediaSetting.Length() == 0)

		{

		return;

		}

	// if the ini file has been opened, the media setting will be either the default

	// or some other string so we can allow logging. If we are only opening media now, output extra info.

	TTime currentMicrosecs;

	currentMicrosecs.HomeTime();

	iCurrentDate = currentMicrosecs.DaysFrom(TTime(TInt64(KZeroDate)));

	if (!iLoggingEnabled)

		{

		iLoggingEnabled = ETrue;

		WriteDateIntoLog(ETrue);

		}

	//Media update is a best effort, if it fails we keep

	//logging to the old media

	//If bad media in ini file, carry on with old media and post message in log

	if (aMediaSetting.CompareF(iCurrentMediaSetting)==0 && aLogPathSetting.CompareF(iLogPath) == 0)

		{

		//Media hasn't changed, so update flush status only

		// ForceFlushing as far as media is concerned only applies to file since 

		// serial has no such buffer which needs flushing.

		iLogger->SetForceFlush(aForceFlush);

		return;

		}

	if (!aMediaSetting.CompareF(KFileMedia))

		{

		CLoggerMediaBase* media = CFileWriter::NewL();

		delete iLogger;

		iLogger = media;

		// ForceFlushing only applies to file since serial has no such buffer

		iLogger->SetForceFlush(aForceFlush);

		if(aLogPathSetting.Length() != 0)

			{

			(static_cast<CFileWriter*>(iLogger))->SetLogPath(aLogPathSetting);

			WriteDateIntoLog(ETrue);

			}

		}

	else if (!aMediaSetting.CompareF(KSerial1Media))

		{

		// lots of things can go wrong when constructing the serial, so

		// we set it up in stages, and log here if an error

		// If we get an error in NewL - just let generic error given by

		// SetMedia cover it

		//CLoggerMediaBase* media = CSerialWriter::NewL();

		CSerialWriter* serial = CSerialWriter::NewL();

		TInt res = serial->LoadDevices();

		if (res != KErrNone)

			{

			TBuf8<KMaxFinalLogStringLength> buf;

			buf.Format(KUnableToLoadSerialDevices,res);

			iLogger->LogString(buf);

			delete serial;

			User::Leave(res);

			}

		res = serial->OpenPort(KSerialPort1);

		if (res != KErrNone)

			{

			TBuf8<KMaxFinalLogStringLength> buf;

			buf.Format(KUnableToOpenSerial,res);

			iLogger->LogString(buf);

			delete serial;

			User::Leave(res);

			}

		res = serial->SetPortConfig();

		if (res != KErrNone)

			{

			TBuf8<KMaxFinalLogStringLength> buf;

			buf.Format(KUnableToSetSerialConfig,res);

			iLogger->LogString(buf);

			delete serial;

			User::Leave(res);

			}

		CLoggerMediaBase* media = serial;

		delete iLogger;

		iLogger = media;

		WriteDateIntoLog(ETrue);

		}

	else if (!aMediaSetting.CompareF(KSerial2Media))

		{

		// lots of things can go wrong when constructing the serial, so

		// we set it up in stages, and log here if an error.

		// If we get an error in NewL - just let generic error given by

		// SetMedia cover it

		CSerialWriter* serial = CSerialWriter::NewL();

		TInt res = serial->LoadDevices();

		if (res != KErrNone)

			{

			TBuf8<KMaxFinalLogStringLength> buf;

			buf.Format(KUnableToLoadSerialDevices,res);

			iLogger->LogString(buf);

			delete serial;

			User::Leave(res);

			}

		#if defined (__WINS__)

		res = serial->OpenPort(KSerialPort2OnEmulator);

		#else

		res = serial->OpenPort(KSerialPort2OnTarget);

		#endif

		if (res != KErrNone)

			{

			TBuf8<KMaxFinalLogStringLength> buf;

			buf.Format(KUnableToOpenSerial,res);

			iLogger->LogString(buf);

			delete serial;

			User::Leave(res);

			}

		res = serial->SetPortConfig();

		if (res != KErrNone)

			{

			TBuf8<KMaxFinalLogStringLength> buf;

			buf.Format(KUnableToSetSerialConfig,res);

			iLogger->LogString(buf);

			delete serial;

			User::Leave(res);

			}

		CLoggerMediaBase* media = serial;

		delete iLogger;

		iLogger = media;

		WriteDateIntoLog(ETrue);

		}

	else if (!aMediaSetting.CompareF(KRDebugMedia))

		{

		CLoggerMediaBase* media = CRDebugWriter::NewL();;

		delete iLogger;

		iLogger = media;

		WriteDateIntoLog(ETrue);

		}

	else if (!aMediaSetting.CompareF(KOSTv2Media))

		{

		CLoggerMediaBase* media = COstv2Writer::NewL();;

		delete iLogger;

		iLogger = media;

		WriteDateIntoLog(ETrue);

		}

	else	//Bad setting in the media file, leave media as is and return.

		{

		iLogger->LogString(KBadMediaString);

		return;	

		}

	iCurrentMediaSetting = aMediaSetting;

	iLogPath = aLogPathSetting;

	}

void CLogManager::ShutDown()

	{

	iShutDown = ETrue;

	}

//////////////////////////////////////////////////////////////////////////////

void CFileWriter::LogString(const TDesC8& aString)

	{

	TPtr8 ptr(iHBuf->Des());

	if (ptr.Length()+aString.Length() <=KHeapBufSize)

		{

		ptr.Append(aString);

		}

	else

		{

		TRAPD(err, DoFlushBufferToFileL());

		if (err==KErrNone)

			{

			ptr.Zero();

			ptr.Append(aString);

			}

		else

			{

			ptr.Zero();

			ptr.Append(KUnableToLog);

			ptr.Append(aString);

			}

		}

	if (iForceBufferFlushAlways)

		{

		TRAPD(err, DoFlushBufferToFileL());

		ptr.Zero();