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

//

/**

 @file

 @internalTechnology

*/

#include <e32base.h>

#include <flogger.h>

#include <hal.h>

#include "suplmemlogger.h"

/** Time interval between the first and second updates. */

const TInt KTimerInitialDelay = 1000000;

/** Time interval between the second and third and all the other updates. */

const TInt KTimerInitialInterval = 2000000;

const TInt KSuplDevLogMaxBufSize = 256;

_LIT(KSuplDevLogFolder, "lbs");

_LIT(KHeader, "TIME\tUID\tSTACK SIZE\tHEAP TOTAL\tHEAP AVAIL\tCHUNK TOTAL\tCHUNK AVAIL\tCELLS TOTAL\tCELLS AVAIL\tH/S TOTAL\tRAM TOTAL\tRAM AVAIL");

_LIT(KLogFormat, "%d\t%x\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d");

EXPORT_C CSuplMemoryUsageLogger* CSuplMemoryUsageLogger::NewLC()

	{

	CSuplMemoryUsageLogger* self = new (ELeave) CSuplMemoryUsageLogger();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CSuplMemoryUsageLogger::CSuplMemoryUsageLogger() :

	iHeap(User::Heap())

	{

	}

CSuplMemoryUsageLogger::~CSuplMemoryUsageLogger()

	{	

	// Cancel and delete periodic timer

	iPeriodic->Cancel();

	delete iPeriodic;

	// Close iLogger handle

	iLogger.Write(KNullDesC8);

	iLogger.Close();

	// Write the max params to a separate file

	WriteMaxHeapToLog();

	// Close RProcess handle

	iProcess.Close();

	}

void CSuplMemoryUsageLogger::ConstructL()

	{	

	//create periodic timer object

	iPeriodic = CPeriodic::NewL(CActive::EPriorityHigh);

	//get process name

	TFileName processFilename(iProcess.FileName());

	//create log file name out of process name

	TInt pos = processFilename.LocateReverse(TChar('\\'));

	iFileName = processFilename.Mid(pos + 1);

	iFileName = iFileName.Mid(0, iFileName.Length() - 3);

	iFileName.Append(_L("txt"));

	//connect to file iLogger

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

	//get total stack size

	RThread currentThread;

	TThreadStackInfo stackInfo;

	currentThread.StackInfo(stackInfo);

	iStackSize = stackInfo.iBase - stackInfo.iLimit;

	//create log file

	iLogger.CreateLog(KSuplDevLogFolder, iFileName, EFileLoggingModeAppend);

	//write header to log file

	iLogger.SetDateAndTime(ETrue, ETrue);

	iLogger.Write(KNullDesC8);

	iLogger.SetDateAndTime(EFalse, EFalse);

	iLogger.WriteFormat(KHeader);

	//setup time stamp for calculating time passed

	iStartTime.UniversalTime();

	//first write to log file

	WriteToLog();

	//start periodic timer

	iPeriodic->Start(KTimerInitialDelay, KTimerInitialInterval, TCallBack(PeriodicCallback, this));

	}

EXPORT_C void CSuplMemoryUsageLogger::Cancel()

	{

	iPeriodic->Cancel();

	}

TInt CSuplMemoryUsageLogger::PeriodicCallback(TAny* aSelf)

	{

	CSuplMemoryUsageLogger* self = static_cast<CSuplMemoryUsageLogger*>(aSelf);

	self->WriteToLog();

	return KErrNone;

	}

void CSuplMemoryUsageLogger::WriteToLog()

	{

	//seconds passed since start of application

	TTime currentTime;

	TTimeIntervalSeconds seconds;

	currentTime.UniversalTime();

	currentTime.SecondsFrom(iStartTime, seconds);

	if (seconds.Int() <= 60)

		{

		TInt heapTotal = 0;

		TInt heapAvail = 0;

		TInt chunkTotal = 0;

		TInt chunkAvail = 0;

		TInt cellsTotal = 0;

		TInt cellsAvail = 0;

		TInt heapStackTotal = 0;

		TInt ramTotal = 0;

		TInt ramAvail = 0;

		//get system memory info from hardware abstraction layer

		HAL::Get(HAL::EMemoryRAM, ramTotal);

		HAL::Get(HAL::EMemoryRAMFree, ramAvail);

		//get process UID

		TSecureId processUid(iProcess.SecureId());

		//get various heap and chunk memory sizes

		iHeap.AllocSize(heapTotal);

		if (heapTotal > iMaxHeapTotal)

			{

			iMaxHeapTotal = heapTotal;

			}

		iHeap.Available(heapAvail);

		chunkTotal = iHeap.Size();

		chunkAvail = chunkTotal - heapTotal;

		if (chunkTotal > iMaxChunkTotal)

			{

			iMaxChunkTotal = chunkTotal;

			}

		//get cells info

		cellsTotal = iHeap.Count(cellsAvail);

		//sum up the total heap and stack sizes

		heapStackTotal = heapTotal + iStackSize;

		//create log text and write to log file

		TBuf16<KSuplDevLogMaxBufSize> logData;

		logData.Format(KLogFormat, seconds.Int(), processUid.iId, iStackSize, heapTotal, heapAvail, chunkTotal, chunkAvail, cellsTotal, cellsAvail, heapStackTotal, ramTotal, ramAvail);

		iLogger.Write(logData);

		}

	}

void CSuplMemoryUsageLogger::WriteMaxHeapToLog()

	{

	_LIT(KLogMaxHeapFormat, "%d, %d");

	//connect to file iLogger

	TInt err = iLogger.Connect();

	if (KErrNone == err)

		{

		//create new log file name out of existing

		TInt pos = iFileName.LocateReverse(TChar('.'));

		if (KErrNotFound != pos)

			{

			iFileName.Insert(pos, _L("_max_ram"));

			//create log file

			iLogger.CreateLog(KSuplDevLogFolder, iFileName, EFileLoggingModeOverwrite);

			//write header to log file

//			iLogger.SetDateAndTime(ETrue, ETrue);

//			iLogger.Write(KNullDesC8);

			iLogger.SetDateAndTime(EFalse, EFalse);

			//create log text and write to log file

			TBuf16<KSuplDevLogMaxBufSize> logData;

			logData.Format(KLogMaxHeapFormat, iMaxHeapTotal, iMaxChunkTotal);

			iLogger.Write(logData);

			iLogger.Write(KNullDesC8);

			}

		iLogger.Close();

		}

	}