/*

 * 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_engine.h"

#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(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::EPriorityLow);

    TCallBack cb(CPULoadCount, aParam);

    idle->Start(cb);

    pS->Start();

    delete idle;

    delete pS;

    delete pC;

    return 0;

    }

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

CPerfMonEngine::CPerfMonEngine() :

    CActive(EPriorityUserInput)

    {

    }

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

void CPerfMonEngine::ConstructL()

    {

    iCurrentCPUMode = ECPUModeNotSet;

    iLogFileInitialized = EFalse;

    iEnv = CEikonEnv::Static();

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

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

    CActiveScheduler::Add(this);

    }

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

void CPerfMonEngine::ActivateEngineL()

    {

    // load settings

    TRAP_IGNORE(LoadSettingsL());

    // create data storages for the samples

    CreateSamplesDataArrayL();

    // set default modes

    HandleSettingsChangeL();

    // start sampling data immediately (jump to RunL)    

    iTimer.After(iStatus, 100);

    SetActive();

    }

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

void CPerfMonEngine::DeActivateEngineL()

    {

    Cancel();

    DeActivateCPUMonitoring();

    // close log file

    OpenLogFile(EFalse);

    }

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

CPerfMonEngine::~CPerfMonEngine()

    {

    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 CPerfMonEngine::DoCancel()

    {

    iTimer.Cancel();

    }

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

void CPerfMonEngine::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 CPerfMonEngine::HandleSettingsChangeL()

    {

    // set priority of the thread

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

    // 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 CPerfMonEngine::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 CPerfMonEngine::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 CPerfMonEngine::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(EPriorityAbsoluteVeryLow);

    iCPULoadThread.Resume();

    iCurrentCPUMode = ECPUModeNOPs; // NOPs taken succesfully in use

    }

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

TBool CPerfMonEngine::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 CPerfMonEngine::DeActivateCPUMonitoring()

    {

    if (iCurrentCPUMode == ECPUModeCPUTime)

        {

        iNullThread.Close();

        }

    else if (iCurrentCPUMode == ECPUModeNOPs)

        {

        // kill the cpu load thread

        iCPULoadThread.Kill(0);

        iCPULoadThread.Close();

        }

    }

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

TBool CPerfMonEngine::CPUTimeSupported()

    {

    TTimeIntervalMicroSeconds time;

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

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

        return ETrue;

    else

        return EFalse;

    }

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

TThreadPriority CPerfMonEngine::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 CPerfMonEngine::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 CPerfMonEngine::UpdateSamplesDataL()

    {

    // reset inactivity timers

    if (iSettings.iKeepBacklightOn)

        User::ResetInactivityTime();

    // get current time

    TTime currentTime;

    currentTime.HomeTime();

    // calculate time difference

    TTimeIntervalMicroSeconds timeDeltaFromPreviousSample =

            currentTime.MicroSecondsFrom(iPreviousTime);

    // remember current time as previous

    iPreviousTime = currentTime;

    // get CPU

    TInt64 cpuLoadDelta(0);

    TInt64 cpuLoadFree(0);

    TInt64 cpuLoadSize(0);

    TInt64 currentCPUValue(0);