/*

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

*

*/

// INCLUDE FILES

#include "perfmon_model.h"

#include "perfmon_app.h"

#include "perfmon_settingsviewdlg.h"

#include "perfmon.hrh"

#include "perfmon_valuescontainer.h"

#include "perfmon_graphscontainer.h"

#include "perfmon_datapopupcontainer.h"

#include <perfmon.rsg>

#include <coeutils.h>

#include <bautils.h>

#include <eikenv.h>

#include <e32hal.h>

#include <u32std.h>

#include <s32file.h>

#include <akntitle.h> 

#include <eikspane.h>

#include <aknnotewrappers.h>  

_LIT(KAppName, "PerfMon");

_LIT(KDefaultLogFilePath, "c:\\data\\PerfMon.log");

const TInt KCalibrationLength = 2;

const TInt KMinimumSamplesLength = 16;

const TInt KCPUTimeMultiplier = 1000000; // used to avoid TReal conversions

const TInt KSettingsDrive = EDriveC;

_LIT(KSettingsFileName, "perfmon_settings.ini");

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

TInt CPULoadCount(TAny* aInt)

	{

	// increase the counter

	(*(TUint*)aInt)++;

	return 1;

	}

TInt CPULoadNOPThread(TAny* aParam)

	{

	CTrapCleanup* pC = CTrapCleanup::New();

	CActiveScheduler* pS = new CActiveScheduler;

	CActiveScheduler::Install(pS);

	CIdle* idle = CIdle::NewL(CActive::EPriorityStandard);

	TCallBack cb(CPULoadCount, aParam);

	idle->Start(cb);

	pS->Start();

	delete idle;

	delete pS;

	delete pC;

	return 0;

	}

// ===================================== MEMBER FUNCTIONS =====================================

CPerfMonModel* CPerfMonModel::NewL()

	{

	CPerfMonModel* self = new(ELeave) CPerfMonModel;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

CPerfMonModel::CPerfMonModel() : CActive(EPriorityUserInput)

	{

	}

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

void CPerfMonModel::ConstructL()

	{

	iDrawState = EDrawStateInvalid;

	iCurrentCPUMode = ECPUModeNotSet;

	iLogFileInitialized = EFalse;

    iEnv = CEikonEnv::Static();

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

    User::LeaveIfError(iTimer.CreateLocal());

	CActiveScheduler::Add(this);

	}

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

void CPerfMonModel::ActivateModelL()

	{

    // load settings

    TRAP_IGNORE(LoadSettingsL());

	// create data storages for the samples

	CreateSamplesDataArrayL();

	// initialize the data popup container in top-right corner

	iDataPopupContainer = new(ELeave) CPerfMonDataPopupContainer;

	iDataPopupContainer->ConstructL(TRect(0,0,1,1));

	// set default modes

	HandleSettingsChangeL();

    // start sampling data immediately (jump to RunL)    

    iTimer.After(iStatus, 100);

    SetActive();

	}

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

void CPerfMonModel::DeActivateModelL()

	{

	Cancel();

	DeActivateCPUMonitoring();

	if (iDataPopupContainer)

	    {

	    delete iDataPopupContainer;

	    iDataPopupContainer = NULL;

	    }

    // close log file

	OpenLogFile(EFalse);

	}

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

CPerfMonModel::~CPerfMonModel()

	{

	iTimer.Close();

    // clear data storages

	if (iSampleEntryArray)

	    {

        for (TInt i=0; i<iSampleEntryArray->Count(); i++)

            {

            delete iSampleEntryArray->At(i).iSampleDataArray;

            }

	    delete iSampleEntryArray;

	    }

	iLs.Close();

    }

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

void CPerfMonModel::DoCancel()

	{

    iTimer.Cancel();

	}

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

void CPerfMonModel::RunL()

	{

	// calculate new values 

	UpdateSamplesDataL();

	// log changes

	AppendLatestSamplesToLogsL();

	// redraw views

	SendDrawEventToContainersL();  

    // continue

    iTimer.After(iStatus, iSettings.iHeartBeat * 1000); // convert from milliseconds to microseconds

    SetActive();

	}

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

void CPerfMonModel::HandleSettingsChangeL()

    {

    // set priority of the thread

    RThread().SetPriority(SettingItemToThreadPriority(iSettings.iPriority));

    // set visibility and location of the data popup

    iDataPopupContainer->UpdateVisibility();

    iDataPopupContainer->SetPositionAndSize();

    // init cpu monitor if setting has been changed

    if (iCurrentCPUMode != iSettings.iCPUMode)

        {

        DeActivateCPUMonitoring();

        ActivateCPUMonitoringL();

        }

    // close log file

    OpenLogFile(EFalse);

    // enable log file

    if (iSettings.iLoggingEnabled && (iSettings.iLoggingMode == ELoggingModeLogFile || iSettings.iLoggingMode == ELoggingModeRDebugLogFile))

        OpenLogFile(ETrue);

    }

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

void CPerfMonModel::EnableLogging(TBool aEnable)

    {

    if (aEnable)

        {

        if (iSettings.iLoggingMode == ELoggingModeLogFile || iSettings.iLoggingMode == ELoggingModeRDebugLogFile)

            OpenLogFile(ETrue);

        iSettings.iLoggingEnabled = ETrue;

        }

    else // disable

        {

        iSettings.iLoggingEnabled = EFalse;

        OpenLogFile(EFalse);

        }

    }

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

void CPerfMonModel::OpenLogFile(TBool aOpen)

    {

    // open log file for writing

    if (aOpen)

        {

        if (!iLogFileInitialized)

            {

            TInt err(KErrNone);

            // open the log file for writing

            if (iLogFile.Open(iEnv->FsSession(), iSettings.iLoggingFilePath, EFileWrite) != KErrNone)

                {

                iEnv->FsSession().MkDirAll(iSettings.iLoggingFilePath);

                err = iLogFile.Replace(iEnv->FsSession(), iSettings.iLoggingFilePath, EFileWrite);

                }

            else

                {

                // file opens correctly, seek to the end

                TInt fileSize=0;

                iLogFile.Size(fileSize);

                err = iLogFile.Seek(ESeekCurrent, fileSize);

                }

            if (err == KErrNone)

                {

                iLogFileInitialized = ETrue;

                }

            else

                {

                // show error

                CAknErrorNote* note = new(ELeave) CAknErrorNote();

                note->ExecuteLD(_L("Unable to create log file, check settings"));                

                }

            }        

        }

    // close handle to log file

    else 

        {

        if (iLogFileInitialized)

            {

            iLogFile.Flush();

            iLogFile.Close();

            iLogFileInitialized = EFalse;

            }

        }

    }

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

void CPerfMonModel::ActivateCPUMonitoringL()

    {

    // reset counter variables

	iCPULoadCalibrating = ETrue;

	iCPULoadCalibrationCounter = 0;

	iCPULoadMaxValue = 999999999;

	iCPULoadPreviousValue = 1;

	iCPULoadCounter = 0;

    // use null thread is cpu time is supported and the setting is on

    if (CPUTimeSupported() && iSettings.iCPUMode == ECPUModeCPUTime) 

        {

        // try to open handle to null thread

        if (OpenHandleToNullThread())

            {

            // handle is open, get initial value

            TTimeIntervalMicroSeconds time;

            iNullThread.GetCpuTime(time);

            iCPULoadPreviousValue = time.Int64();

            iPreviousTime.HomeTime();

            iCurrentCPUMode = ECPUModeCPUTime;

            return; // cpu time is succesfully in use           

            }

        }

    // otherwise use normal sampling with nops    

    iCurrentCPUMode = ECPUModeNotSet;

    // show a warning if cpu time cannot be taken in use

    if (iSettings.iCPUMode == ECPUModeCPUTime)

        {

        CAknInformationNote* note = new(ELeave) CAknInformationNote();

        note->ExecuteLD(_L("CPU Time not supported in this system, using NOPs sampling"));

        }

    // create a thread for CPU load monitoring

    User::LeaveIfError(iCPULoadThread.Create(_L("PerfMonCPULoad"), CPULoadNOPThread, 0x1000, 0x1000, 0x100000, &iCPULoadCounter));

    iCPULoadThread.SetPriority(EPriorityLess);

    iCPULoadThread.Resume();    

    iCurrentCPUMode = ECPUModeNOPs; // NOPs taken succesfully in use

    }

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

TBool CPerfMonModel::OpenHandleToNullThread()

    {

    // find the kernel process and then the null thread

    TFindProcess fp(_L("ekern.exe*"));

    TFullName kernelName;

    if (fp.Next(kernelName) == KErrNone)

        {

        // process found, append null thread identifier

        kernelName.Append(_L("::Null"));

        // find the thread

        TFindThread ft(kernelName);

        TFullName threadName;

        if (ft.Next(threadName) == KErrNone)

            {

            // open instance to the thread

            if (iNullThread.Open(threadName) != KErrNone)

                return EFalse;                

            }

        }

    // process not found

    else

        return EFalse;

    // success!

    return ETrue;        

    }

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

void CPerfMonModel::DeActivateCPUMonitoring()

    {

    if (iCurrentCPUMode == ECPUModeCPUTime)

        {

        iNullThread.Close();

        }

    else if (iCurrentCPUMode == ECPUModeNOPs)    

        {

        // kill the cpu load thread

        iCPULoadThread.Kill(0);

        iCPULoadThread.Close();        

        } 

    }

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

TBool CPerfMonModel::CPUTimeSupported()

    {

    TTimeIntervalMicroSeconds time;

    TInt err = RThread().GetCpuTime(time);

    if (err == KErrNone && time.Int64() > 0)

        return ETrue;

    else

        return EFalse;

    }

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

TThreadPriority CPerfMonModel::SettingItemToThreadPriority(TInt aIndex)

    {

    TThreadPriority threadPriority = EPriorityNull;

    switch ( aIndex )

        {

        case EThreadPriorityTypeMuchLess:

            {

            threadPriority = EPriorityMuchLess; break;

            }

        case EThreadPriorityTypeLess:

            {

            threadPriority = EPriorityLess; break;

            }

        case EThreadPriorityTypeNormal:

            {

            threadPriority = EPriorityNormal; break;

            }

        case EThreadPriorityTypeMore:

            {

            threadPriority = EPriorityMore; break;

            }

        case EThreadPriorityTypeMuchMore:

            {

            threadPriority = EPriorityMuchMore; break;

            }

        case EThreadPriorityTypeRealTime:

            {

            threadPriority = EPriorityRealTime; break;

            }

        case EThreadPriorityTypeAbsoluteVeryLow:

            {

            threadPriority = EPriorityAbsoluteVeryLow; break;

            }

        case EThreadPriorityTypeAbsoluteLow:

            {

            threadPriority = EPriorityAbsoluteLow; break;

            }

        case EThreadPriorityTypeAbsoluteBackground:

            {

            threadPriority = EPriorityAbsoluteBackground; break;

            }

        case EThreadPriorityTypeAbsoluteForeground:

            {

            threadPriority = EPriorityAbsoluteForeground; break;

            }

        case EThreadPriorityTypeAbsoluteHigh:

            {

            threadPriority = EPriorityAbsoluteHigh; break;

            }

        default:

            {

            User::Panic(_L("Wrong tp index"), 276);

            break;

            }

        }

    return threadPriority;

    }

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

void CPerfMonModel::CreateSamplesDataArrayL()

    {

    TInt maxSamples = iSettings.iMaxSamples >= KMinimumSamplesLength ? iSettings.iMaxSamples : KMinimumSamplesLength;

    // create the data structure to store all samples

    iSampleEntryArray = new(ELeave) CSampleEntryArray(16);

    // add all source entries

    for (TInt i=0; i<ESourcesLength; i++)

        {

        TSampleEntry newSampleEntry;

        if (i == ESourceCPU)

            {

            newSampleEntry.iDescription.Copy(_L("CPU"));

            newSampleEntry.iUnitTypeShort.Copy(KNullDesC);

            newSampleEntry.iUnitTypeLong.Copy(KNullDesC);

            newSampleEntry.iDriveNumber = -1;

            newSampleEntry.iGraphColor = KRgbYellow;            

            }

        else if (i == ESourceRAM)

            {

            newSampleEntry.iDescription.Copy(_L("RAM"));

            newSampleEntry.iUnitTypeShort.Copy(_L("b"));

            newSampleEntry.iUnitTypeLong.Copy(_L("bytes"));

            newSampleEntry.iDriveNumber = -1;

            newSampleEntry.iGraphColor = KRgbGreen;            

            }        

        else //drives

            {

            TChar driveLetter = 'C' + i-ESourceC; // C is the first drive

            newSampleEntry.iDescription.Append(driveLetter);

            newSampleEntry.iDescription.Append(_L(":"));

            newSampleEntry.iUnitTypeShort.Copy(_L("b"));

            newSampleEntry.iUnitTypeLong.Copy(_L("bytes"));

            iEnv->FsSession().CharToDrive(driveLetter, newSampleEntry.iDriveNumber);

            newSampleEntry.iGraphColor = KRgbCyan;

            newSampleEntry.iGraphColor.SetGreen(255-(i-ESourceC)*30);

            newSampleEntry.iGraphColor.SetRed(i*30);

            }

        newSampleEntry.iSampleDataArray = new(ELeave) CSampleDataArray(maxSamples); 

        iSampleEntryArray->AppendL(newSampleEntry);        

        }

    // save current time as start time

    iStartTime.HomeTime();

    }

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

void CPerfMonModel::UpdateSamplesDataL()

    {

    // reset inactivity timers

    if (iSettings.iKeepBacklightOn)

        User::ResetInactivityTime();