diff -r 5db69f4c3d06 -r b048e15729d6 perfapps/perfmon/engine/src/perfmon_engine.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/perfapps/perfmon/engine/src/perfmon_engine.cpp	Fri Sep 03 17:11:21 2010 +0300
@@ -0,0 +1,1129 @@
+/*
+ * 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 "perfmon_powerlistener.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* aPtr)
+    {
+    TPerfMonNOPCounter& atts = *((TPerfMonNOPCounter*) aPtr);
+
+    // increase the counter
+    atts.iCounterValue++;
+    return 1;
+    }
+
+TInt CPULoadNOPThread(TAny* aPtr)
+    {
+    // set the thread running in correct CPU
+    TPerfMonNOPCounter& atts = *((TPerfMonNOPCounter*) aPtr);
+    
+    if (atts.iAmountOfCPUs > 1)
+        {
+        // request via HAL that the current thread will run in CPU defined in atts.iCPUNumber
+        TInt err = UserSvr::HalFunction(EHalGroupKernel, 19 /*EKernelHalLockThreadToCpu*/, (TAny*) atts.iCPUNumber, 0);
+
+        if (err != KErrNone)
+            {
+            // error, stop this thread
+            return err;
+            }
+        }
+
+    // init trap clean and install active scheduler
+    CTrapCleanup* pC = CTrapCleanup::New();
+    CActiveScheduler* pS = new CActiveScheduler;
+    CActiveScheduler::Install(pS);
+
+    // call the counter to simulate polling the null thread for cpu time
+    CIdle* idle = CIdle::NewL(CActive::EPriorityStandard);
+    TCallBack cb(CPULoadCount, aPtr);
+    idle->Start(cb);
+
+    pS->Start();
+
+    delete idle;
+    delete pS;
+    delete pC;
+
+    return KErrNone;
+    }
+
+// ===================================== MEMBER FUNCTIONS =====================================
+
+CPerfMonEngine::CPerfMonEngine() :
+    CActive(EPriorityUserInput),
+    iPowerClient(0)
+    {
+    }
+
+// --------------------------------------------------------------------------------------------
+
+void CPerfMonEngine::ConstructL()
+    {
+    iCurrentCPUMode = ECPUModeNotSet;
+    iLogFileInitialized = EFalse;
+    iAmountOfCPUs = 1;
+
+    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();
+
+    DeActivatePowerMonitoring();
+    DeActivateCPUMonitoring();
+
+    // close log file
+    OpenLogFile(EFalse);
+    }
+
+// --------------------------------------------------------------------------------------------
+
+CPerfMonEngine::~CPerfMonEngine()
+    {
+    DeActivatePowerMonitoring();
+
+    if (iPowerClient)
+        {
+        delete iPowerClient;
+        iPowerClient = 0;
+        }
+
+    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();
+        }
+
+    // Check for power setting changes every time
+    if (iSettings.iPowerMonitoringEnabled)
+        {
+        ActivatePowerMonitoringL();
+        }
+    else
+        {
+        DeActivatePowerMonitoring();
+        }
+
+    // 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;
+
+    for (TInt i=0; i<KMaxCPUs; i++)
+        {
+        iCPULoadPreviousValue[i] = 1;
+        }
+
+    // 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 for each CPU
+            for (TInt i=0; i<iAmountOfCPUs; i++)
+                {
+                TTimeIntervalMicroSeconds time;
+                iNullThreads[i].GetCpuTime(time);
+                iCPULoadPreviousValue[i] = 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"));
+        }
+
+    // get the amount of CPUs
+    iAmountOfCPUs = GetAmountOfCPUs();
+
+    // create a thread for CPU load monitoring
+    for (TInt i=0; i<iAmountOfCPUs; i++)
+        {
+        // initialize the NOP counter variables
+        iCPULoadNOPCounter[i].iCounterValue = 0;
+        iCPULoadNOPCounter[i].iCPUNumber = i;
+        iCPULoadNOPCounter[i].iAmountOfCPUs = iAmountOfCPUs;
+
+        // create a name for the thread
+        TFileName cpuLoadThreadName;
+        cpuLoadThreadName.Copy(_L("PerfMonCPULoadNOPThread"));
+        cpuLoadThreadName.AppendNum(i);
+        
+        // create the thread and resume it
+        User::LeaveIfError(iCPULoadNOPThread[i].Create(cpuLoadThreadName,
+                CPULoadNOPThread, 0x1000, 0x1000, 0x100000, &iCPULoadNOPCounter[i]));
+        iCPULoadNOPThread[i].SetPriority(EPriorityLess);
+        iCPULoadNOPThread[i].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)
+        {
+        iAmountOfCPUs = 0;
+
+        // find all null threads in the system by following the order ie "Null", "Null1", "Null2", "Null3"
+        for (TInt i(0); i<KMaxCPUs; i++)
+            {
+            // construct name of the null thread from the process name
+            TFullName nullThreadName(kernelName);
+            nullThreadName.Append(_L("::Null"));
+            
+            if (i >= 1) // add identifier for CPUs higher than zero
+                nullThreadName.AppendNum(i);
+
+            TFindThread ft(nullThreadName);
+            TFullName threadName;
+
+            if (ft.Next(threadName) == KErrNone)
+                {
+                if (iNullThreads[i].Open(threadName) != KErrNone)
+                    return EFalse;
+                
+                iAmountOfCPUs++;
+                }
+            else
+                {
+                break;  // break the loop, no more matches can be found
+                }
+            }
+        }
+
+    // process not found
+    else
+        return EFalse;
+
+    // success!
+    return ETrue;
+    }
+
+// --------------------------------------------------------------------------------------------
+
+void CPerfMonEngine::DeActivateCPUMonitoring()
+    {
+    if (iCurrentCPUMode == ECPUModeCPUTime)
+        {
+        // close handles to null threads
+        for (TInt i=0;i<iAmountOfCPUs;i++)
+            {
+            iNullThreads[i].Close();
+            }
+        }
+
+    else if (iCurrentCPUMode == ECPUModeNOPs)
+        {
+        // kill the cpu load thread
+        for (TInt i=0;i<iAmountOfCPUs;i++)
+            {
+            iCPULoadNOPThread[i].Kill(0);
+            iCPULoadNOPThread[i].Close();
+            }
+        }
+    }
+
+// --------------------------------------------------------------------------------------------
+
+TBool CPerfMonEngine::CPUTimeSupported()
+    {
+    TTimeIntervalMicroSeconds time;
+    TInt err = RThread().GetCpuTime(time);
+
+    if (err == KErrNone && time.Int64() > 0)
+        return ETrue;
+    else
+        return EFalse;
+    }
+
+// --------------------------------------------------------------------------------------------
+
+TInt CPerfMonEngine::GetAmountOfCPUs()
+    {
+    // query from HAL the amount of CPUs and then check it returns a valid value
+    TInt amountOfCPUs = UserSvr::HalFunction(EHalGroupKernel, 16 /*EKernelHalNumLogicalCpus*/, 0, 0);
+    
+    if (amountOfCPUs >= 1 && amountOfCPUs <= KMaxCPUs)
+        return amountOfCPUs;
+    else
+        return 1; // HAL may not support this feature, so just return one CPU
+    }
+
+// --------------------------------------------------------------------------------------------
+
+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);
+
+    // set sample data array positions for each type
+    iCPU0PositionInSamples = 0;
+    iRAMPositionInSamples = KMaxCPUs;
+    iCDrivePositionInSamples = KMaxCPUs+1;
+    iPowerPositionInSamples = iCDrivePositionInSamples + ( ESourceI - ESourceC ) + 1;
+
+    // add all CPU source entries
+    for (TInt i=0; i<KMaxCPUs; i++)
+        {
+        TSampleEntry newSampleEntry;
+
+        newSampleEntry.iDescription.Copy(_L("CPU"));
+        newSampleEntry.iDescription.AppendNum(i);
+
+        newSampleEntry.iUnitTypeShort.Copy(KNullDesC);
+        newSampleEntry.iUnitTypeLong.Copy(KNullDesC);
+        newSampleEntry.iDriveNumber = -1;
+        newSampleEntry.iGraphColor = KRgbYellow;
+        newSampleEntry.iGraphColor.SetGreen(255-i*75);
+        newSampleEntry.iGraphColor.SetBlue(i*75);
+
+        newSampleEntry.iSampleDataArray = new(ELeave) CSampleDataArray(maxSamples);
+        iSampleEntryArray->AppendL(newSampleEntry);
+        }
+
+    // add RAM entry
+    {
+    TSampleEntry newSampleEntry;
+
+    newSampleEntry.iDescription.Copy(_L("RAM"));
+    newSampleEntry.iUnitTypeShort.Copy(_L("b"));
+    newSampleEntry.iUnitTypeLong.Copy(_L("bytes"));
+    newSampleEntry.iDriveNumber = -1;
+    newSampleEntry.iGraphColor = KRgbGreen;
+
+    newSampleEntry.iSampleDataArray = new(ELeave) CSampleDataArray(maxSamples);
+    iSampleEntryArray->AppendL(newSampleEntry);
+    }
+
+    // add all disk drives
+    for (TInt i=0; i<ESourceI-ESourceC+1; i++)
+        {
+        TSampleEntry newSampleEntry;
+
+        TChar driveLetter = 'C' + i; // 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);
+        }
+
+    // add power entry
+    {
+    TSampleEntry newSampleEntry;
+
+    newSampleEntry.iDescription.Copy(_L("Power"));
+    newSampleEntry.iUnitTypeShort.Copy(_L("mW"));
+    newSampleEntry.iUnitTypeLong.Copy(_L("milliwatts"));
+    newSampleEntry.iDriveNumber = -1;
+    newSampleEntry.iGraphColor = KRgbRed;
+
+    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 load value for each CPU
+    for (TInt i=0;i<iAmountOfCPUs;i++)
+        {
+        TInt64 cpuLoadDelta(0);
+        TInt64 cpuLoadFree(0);
+        TInt64 currentCPUValue(0);
+        
+        if (iCurrentCPUMode == ECPUModeCPUTime || iCurrentCPUMode == ECPUModeNOPs)
+            {
+            if (iCurrentCPUMode == ECPUModeCPUTime)
+                {
+                // get CPU time of null thread
+                TTimeIntervalMicroSeconds time;
+                iNullThreads[i].GetCpuTime(time);
+                currentCPUValue = time.Int64();
+                }
+            else if (iCurrentCPUMode == ECPUModeNOPs)
+                {
+                // get CPU time from sampler
+                currentCPUValue = iCPULoadNOPCounter[i].iCounterValue;
+                }
+
+            // get delta and store the previous value
+            cpuLoadDelta = currentCPUValue - iCPULoadPreviousValue[i];
+            iCPULoadPreviousValue[i] = currentCPUValue;
+            
+            // velocity = distance / time
+            cpuLoadFree = cpuLoadDelta * KCPUTimeMultiplier / timeDeltaFromPreviousSample.Int64();
+
+            // detect maximum value (this is common to all CPUs)
+            if (cpuLoadFree > iCPULoadMaxValue)
+                {
+                iCPULoadMaxValue = cpuLoadFree;
+                }
+            }
+
+        // save cpu sample data
+        TSampleData cpuSample;
+        cpuSample.iFree = cpuLoadFree;
+        cpuSample.iSize = iCPULoadCalibrating ? cpuLoadFree : iCPULoadMaxValue;  // if calibrating, size==free, otherwise store the correct size value
+        cpuSample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
+
+        iSampleEntryArray->At(i).iSampleDataArray->InsertL(0, cpuSample);
+        }
+        
+    // check calibration status, the calibration will be only done against CPU0
+    if (iCPULoadCalibrating)
+        {
+        iCPULoadCalibrationCounter++;
+        TInt64 cpuLoadSize = iSampleEntryArray->At(iCPU0PositionInSamples).iSampleDataArray->At(0).iSize;
+        
+        // check if need to calibrate anymore
+        if (iCPULoadCalibrationCounter > KCalibrationLength)
+            {
+            iCPULoadCalibrating = EFalse;
+            
+            // from the samples, get the minimum value, and let it be the max value
+            for (TInt i=0; i<iSampleEntryArray->At(0).iSampleDataArray->Count(); i++)
+                {
+                TInt64 newCPULoadMaxValue = iCPULoadMaxValue;
+                
+                if (iSampleEntryArray->At(0).iSampleDataArray->At(i).iFree < newCPULoadMaxValue)
+                    {
+                    newCPULoadMaxValue = iSampleEntryArray->At(0).iSampleDataArray->At(i).iFree;
+                    }
+                
+                iCPULoadMaxValue = newCPULoadMaxValue;
+                }
+            
+            // adjust priority of the poller thread
+            if (iCurrentCPUMode == ECPUModeNOPs)
+                {
+                for (TInt i=0; i<iAmountOfCPUs; i++)
+                    {
+                    iCPULoadNOPThread[i].SetPriority(EPriorityAbsoluteVeryLow);
+                    }
+                }
+
+            }
+        }
+
+    // get ram memory
+    TMemoryInfoV1Buf ramMemory;
+    UserHal::MemoryInfo(ramMemory);
+
+    TSampleData memorySample;
+    memorySample.iFree = ramMemory().iFreeRamInBytes;
+    memorySample.iSize = ramMemory().iMaxFreeRamInBytes;
+    memorySample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
+
+    iSampleEntryArray->At(iRAMPositionInSamples).iSampleDataArray->InsertL(0, memorySample);
+    
+    // all drives
+    for (TInt i = iCDrivePositionInSamples; i < iPowerPositionInSamples; i++)
+        {
+        TSampleData driveSample;
+
+        // get volume info from RFs
+        TVolumeInfo volumeInfo;
+        if (iEnv->FsSession().Volume(volumeInfo,
+                iSampleEntryArray->At(i).iDriveNumber) == KErrNone)
+            {
+            driveSample.iFree = volumeInfo.iFree;
+            driveSample.iSize = volumeInfo.iSize;
+            }
+        else
+            {
+            driveSample.iFree = 0;
+            driveSample.iSize = 0;
+            }
+
+        driveSample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
+
+        iSampleEntryArray->At(i).iSampleDataArray->InsertL(0, driveSample);
+        }
+
+    // Power data
+    TSampleData powerSample;
+    if (iSettings.iPowerMonitoringEnabled)
+        {
+        // Values in milliwatts
+        powerSample.iFree = ( iPowerClient->GetMaxPower() - iPowerClient->GetPower() ) / 1000;
+        powerSample.iSize = iPowerClient->GetMaxPower() / 1000;
+        }
+    else
+        {
+        powerSample.iFree = 0;
+        powerSample.iSize = 0;
+        }
+
+    powerSample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
+
+    iSampleEntryArray->At(iPowerPositionInSamples).iSampleDataArray->InsertL(0, powerSample);
+
+    // compress sample data arrays to save memory
+    TInt curLength(iSampleEntryArray->At(0).iSampleDataArray->Count());
+
+    TInt maxSamples =
+            iSettings.iMaxSamples >= KMinimumSamplesLength ? iSettings.iMaxSamples
+                    : KMinimumSamplesLength;
+
+    if (curLength > maxSamples && curLength % 5 == 0)
+        {
+        for (TInt i = 0; i < iSampleEntryArray->Count(); i++)
+            {
+            if (SampleEntryArray()->At(i).iSampleDataArray->Count() > 0)
+                {
+                iSampleEntryArray->At(i).iSampleDataArray->ResizeL(maxSamples); // looses old samples
+                iSampleEntryArray->At(i).iSampleDataArray->Compress();
+                }
+            }
+        }
+    }
+
+// --------------------------------------------------------------------------------------------
+
+void CPerfMonEngine::AppendLatestSamplesToLogsL()
+    {
+    if (iSettings.iLoggingEnabled && SampleEntryArray())
+        {
+        // loop all sources
+        for (TInt i = 0; i < SampleEntryArray()->Count(); i++)
+            {
+            // check if this setting has been enabled and it has some data
+            if (iSettings.iLoggingSources.iSrcEnabled[SampleEntryPosToSettingPos(i)]
+                    && SampleEntryArray()->At(i).iSampleDataArray->Count() > 0)
+                {
+                // get current sample
+                TSampleData& currentSample =
+                        SampleEntryArray()->At(i).iSampleDataArray->At(0);
+
+                TBuf<128> buf;
+                buf.Append(_L("PERFMON;"));
+                buf.Append(SampleEntryArray()->At(i).iDescription);
+                buf.Append(_L(";"));
+                buf.AppendNum(currentSample.iTimeFromStart.Int64());
+                buf.Append(_L(";"));
+                buf.AppendNum(currentSample.iFree);
+                buf.Append(_L(";"));
+                buf.AppendNum(currentSample.iSize);
+
+                // print to RDebug
+                if (iSettings.iLoggingMode == ELoggingModeRDebug
+                        || iSettings.iLoggingMode == ELoggingModeRDebugLogFile)
+                    {
+                    RDebug::Print(buf);
+                    }
+
+                // print to log file
+                if (iSettings.iLoggingMode == ELoggingModeLogFile
+                        || iSettings.iLoggingMode == ELoggingModeRDebugLogFile)
+                    {
+                    buf.Append(_L("\r\n"));
+
+                    TBuf8<128> buf8;
+                    buf8.Copy(buf);
+
+                    iLogFile.Write(buf8);
+                    }
+                }
+            }
+        }
+    }
+
+void CPerfMonEngine::LoadSettingsL()
+    {
+    // set defaults
+    iSettings.iHeartBeat = 600;
+    iSettings.iMaxSamples = 64;
+    iSettings.iPriority = EThreadPriorityTypeNormal;
+    iSettings.iCPUMode = ECPUModeCPUTime;
+    iSettings.iKeepBacklightOn = ETrue;
+
+    iSettings.iDataPopupVisibility = EDataPopupVisbilityAlwaysOn;
+    iSettings.iDataPopupLocation = EDataPopupLocationTopRight;
+    iSettings.iDataPopupSources.SetDefaults1();
+
+    iSettings.iGraphsVerticalBarPeriod = 5;
+    iSettings.iGraphsSources.SetDefaults2();
+
+    iSettings.iLoggingMode = ELoggingModeRDebug;
+    iSettings.iLoggingFilePath.Copy(KDefaultLogFilePath);
+    iSettings.iLoggingSources.SetDefaults2();
+
+    iSettings.iLoggingEnabled = EFalse;
+
+    iSettings.iPowerMonitoringEnabled = ETrue;
+
+    // make sure that the private path of this app in c-drive exists
+    iEnv->FsSession().CreatePrivatePath(KSettingsDrive); // c:\\private\\20011385\\
+    
+    // handle settings always in the private directory 
+    if (iEnv->FsSession().SetSessionToPrivate(KSettingsDrive) == KErrNone)
+        {
+        const TUid KUidPerfMon =
+            {
+            0x20011385
+            };
+        // open or create a dictionary file store
+        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(
+                iEnv->FsSession(), KSettingsFileName, KUidPerfMon);
+
+        LoadDFSValueL(settingsStore, KPMSettingHeartBeat, iSettings.iHeartBeat);
+        LoadDFSValueL(settingsStore, KPMSettingMaxSamples,
+                iSettings.iMaxSamples);
+        LoadDFSValueL(settingsStore, KPMSettingPriority, iSettings.iPriority);
+        
+        LoadDFSValueL(settingsStore, KPMSettingCPUMode, iSettings.iCPUMode);
+        
+        LoadDFSValueL(settingsStore, KPMSettingKeepBackLightOn,
+                iSettings.iKeepBacklightOn);
+
+        LoadDFSValueL(settingsStore, KPMSettingDataPopupVisbility,
+                iSettings.iDataPopupVisibility);
+        LoadDFSValueL(settingsStore, KPMSettingDataPopupLocation,
+                iSettings.iDataPopupLocation);
+        LoadDFSValueL(settingsStore, KPMSettingDataPopupSources,
+                iSettings.iDataPopupSources);
+
+        LoadDFSValueL(settingsStore, KPMSettingGraphsVerticalBarPeriod,
+                iSettings.iGraphsVerticalBarPeriod);
+        LoadDFSValueL(settingsStore, KPMSettingGraphsSources,
+                iSettings.iGraphsSources);
+
+        LoadDFSValueL(settingsStore, KPMSettingLoggingMode,
+                iSettings.iLoggingMode);
+        LoadDFSValueL(settingsStore, KPMSettingLoggingFilePath,
+                iSettings.iLoggingFilePath);
+        LoadDFSValueL(settingsStore, KPMSettingLoggingSources,
+                iSettings.iLoggingSources);
+
+        LoadDFSValueL(settingsStore, KPMSettingPowerMonitoringEnabled,
+                iSettings.iPowerMonitoringEnabled);
+
+        CleanupStack::PopAndDestroy(); // settingsStore
+        }
+    }
+
+// --------------------------------------------------------------------------------------------
+
+void CPerfMonEngine::SaveSettingsL()
+    {
+    // handle settings always in c:\\private\\20011385\\ 
+    if (iEnv->FsSession().SetSessionToPrivate( KSettingsDrive ) == KErrNone)
+        {
+        // delete existing store to make sure that it is clean and not eg corrupted
+        if (BaflUtils::FileExists(iEnv->FsSession(), KSettingsFileName))
+            {
+            iEnv->FsSession().Delete(KSettingsFileName);
+            }
+        const TUid KUidPerfMon =
+            {
+            0x20011385
+            };
+        // create a dictionary file store
+        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(
+                iEnv->FsSession(), KSettingsFileName, KUidPerfMon);
+
+        SaveDFSValueL(settingsStore, KPMSettingHeartBeat, iSettings.iHeartBeat);
+        SaveDFSValueL(settingsStore, KPMSettingMaxSamples,
+                iSettings.iMaxSamples);
+        SaveDFSValueL(settingsStore, KPMSettingPriority, iSettings.iPriority);
+        SaveDFSValueL(settingsStore, KPMSettingCPUMode, iSettings.iCPUMode);
+        SaveDFSValueL(settingsStore, KPMSettingKeepBackLightOn,
+                iSettings.iKeepBacklightOn);
+
+        SaveDFSValueL(settingsStore, KPMSettingDataPopupVisbility,
+                iSettings.iDataPopupVisibility);
+        SaveDFSValueL(settingsStore, KPMSettingDataPopupLocation,
+                iSettings.iDataPopupLocation);
+        SaveDFSValueL(settingsStore, KPMSettingDataPopupSources,
+                iSettings.iDataPopupSources);
+
+        SaveDFSValueL(settingsStore, KPMSettingGraphsVerticalBarPeriod,
+                iSettings.iGraphsVerticalBarPeriod);
+        SaveDFSValueL(settingsStore, KPMSettingGraphsSources,
+                iSettings.iGraphsSources);
+
+        SaveDFSValueL(settingsStore, KPMSettingLoggingMode,
+                iSettings.iLoggingMode);
+        SaveDFSValueL(settingsStore, KPMSettingLoggingFilePath,
+                iSettings.iLoggingFilePath);
+        SaveDFSValueL(settingsStore, KPMSettingLoggingSources,
+                iSettings.iLoggingSources);
+
+        SaveDFSValueL(settingsStore, KPMSettingPowerMonitoringEnabled,
+                iSettings.iPowerMonitoringEnabled);
+
+        settingsStore->CommitL();
+        CleanupStack::PopAndDestroy(); // settingsStore
+        }
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS,
+        const TUid& aUid, TInt& aValue)
+    {
+    if (aDicFS->IsPresentL(aUid))
+        {
+        RDictionaryReadStream in;
+        in.OpenLC(*aDicFS, aUid);
+        aValue = in.ReadInt16L();
+        CleanupStack::PopAndDestroy(); // in        
+        }
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS,
+        const TUid& aUid, TDes& aValue)
+    {
+    if (aDicFS->IsPresentL(aUid))
+        {
+        RDictionaryReadStream in;
+        in.OpenLC(*aDicFS, aUid);
+        TInt bufLength = in.ReadInt16L(); // get length of descriptor
+        in.ReadL(aValue, bufLength); // get the descriptor itself
+        CleanupStack::PopAndDestroy(); // in
+        }
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS,
+        const TUid& aUid, TPerfMonSources& aValue)
+    {
+    if (aDicFS->IsPresentL(aUid))
+        {
+        RDictionaryReadStream in;
+        in.OpenLC(*aDicFS, aUid);
+        TInt bufLength = in.ReadInt16L(); // get length of the array
+
+        if (bufLength < 0 || bufLength > ESourcesLength) // check for validaty
+            User::Leave(KErrNotSupported);
+
+        for (TInt i = 0; i < bufLength; i++) // get all items
+            aValue.iSrcEnabled[i] = in.ReadInt16L();
+
+        CleanupStack::PopAndDestroy(); // in
+        }
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS,
+        const TUid& aUid, const TInt& aValue)
+    {
+    RDictionaryWriteStream out;
+    out.AssignLC(*aDicFS, aUid);
+    out.WriteInt16L(aValue);
+    out.CommitL();
+    CleanupStack::PopAndDestroy(); // out
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS,
+        const TUid& aUid, const TDes& aValue)
+    {
+    RDictionaryWriteStream out;
+    out.AssignLC(*aDicFS, aUid);
+    out.WriteInt16L(aValue.Length()); // write length of the descriptor
+    out.WriteL(aValue, aValue.Length()); // write the descriptor itself
+    out.CommitL();
+    CleanupStack::PopAndDestroy(); // out
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS,
+        const TUid& aUid, const TPerfMonSources& aValue)
+    {
+    RDictionaryWriteStream out;
+    out.AssignLC(*aDicFS, aUid);
+
+    out.WriteInt16L(ESourcesLength); // write length of the array
+
+    for (TInt i = 0; i < ESourcesLength; i++) // write all items
+        out.WriteInt16L(aValue.iSrcEnabled[i]);
+
+    out.CommitL();
+    CleanupStack::PopAndDestroy(); // out
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::ActivatePowerMonitoringL()
+    {
+    if (!iPowerClient)
+        {
+        iPowerClient = CPerfMonPowerListener::NewL();
+        }
+
+    // disable power monitoring if initialization fails
+    TInt err = iPowerClient->Activate();
+    if (err != KErrNone )
+        {
+        DeActivatePowerMonitoring();
+
+        iSettings.iPowerMonitoringEnabled = EFalse;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+
+void CPerfMonEngine::DeActivatePowerMonitoring()
+    {
+    if (iPowerClient)
+        {
+        iPowerClient->DeActivate();
+        }
+    }
+
+// ---------------------------------------------------------------------------
+
+TInt CPerfMonEngine::SampleEntryPosToSettingPos(TInt aSampleEntryPos)
+    {
+    TInt settingPos(0); // return position of aSampleEntryPos in settings
+    
+    if (aSampleEntryPos >= iCPU0PositionInSamples && aSampleEntryPos < iRAMPositionInSamples)
+        {
+        settingPos = ESourceCPU;
+        }
+    else if (aSampleEntryPos == iRAMPositionInSamples)
+        {
+        settingPos = ESourceRAM;
+        }
+    else
+        {
+        settingPos = ESourceC + (aSampleEntryPos-iCDrivePositionInSamples);
+        }
+    
+    return settingPos;
+    }
+
+// End of File