/*

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

#include <piprofiler/ProfilerTraces.h>

#include <centralrepository.h>

#include <HWRMPower.h>

#include <HWRMLight.h>

#include <hwrm/hwrmpowerdomaincrkeys.h>

// texts for notes

_LIT(KPowerTextLine1, "Power sampler:");

_LIT(KPowerTextLine2, "Failed to start power measurement");

_LIT(KPowerTextErrorSampling, "Error receiving measurement data");

_LIT(KButtonOk, "Ok");

// LITERALS

_LIT8(KSamplingPeriodMs, "sampling_period_ms");

// CONSTANTS

// Use this UID if plugin is PwrPlugin:

const TUid KSamplerPwrPluginUid = { 0x2001E5B9 };

/*

 *

 * class CPwrPlugin implementation

 * 

 */

CPwrPlugin* CPwrPlugin::NewL(const TUid /*aImplementationUid*/, TAny* aInitParams)

    {

    LOGTEXT(_L("CPwrPlugin::NewL() - entry"));

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    LOGTEXT(_L("CPwrPlugin::NewL() - exit"));

    return self;

    }

CPwrPlugin::CPwrPlugin() :

    iVersionDescriptor(&(this->iVersion[1]),0,19),

    iSamplerType(PROFILER_USER_MODE_SAMPLER)

    {

    iPeriod = 250;

    iSamplerId = PROFILER_PWR_SAMPLER_ID;

    iEnabled = EFalse;

    iPowerListener = NULL;

    LOGTEXT(_L("CPwrPlugin::CPwrPlugin() - konstruktori"));

    }

void CPwrPlugin::ConstructL() 

    {

    LOGTEXT(_L("CPwrPlugin::ConstructL() - entry"));

    // initiate sampler attributes array

    iSamplerAttributes = new(ELeave) CArrayFixFlat<TSamplerAttributes>(1); // only one sampler

    // insert default attributes to array

    InitiateSamplerAttributesL();

    LOGTEXT(_L("CPwrPlugin::ConstructL() - exit"));

    }

CPwrPlugin::~CPwrPlugin()

    {

    LOGTEXT(_L("CPwrPlugin::~CPwrPlugin() - entry"));

    if(iPowerListener)

        {

        if(Enabled())

            {

            iPowerListener->Stop();

            }

        delete iPowerListener;

        iPowerListener = NULL;

        }

    if(iSamplerAttributes)

        {

        iSamplerAttributes->Reset();

        delete iSamplerAttributes;

        iSamplerAttributes = NULL;

        }

    LOGTEXT(_L("CPwrPlugin::~CPwrPlugin() - exit"));

    }

TUid CPwrPlugin::Id(TInt /*aSubId*/) const

    {

    LOGSTRING2( "CPwrPlugin::Id():0x%X", KSamplerPwrPluginUid.iUid );

    return KSamplerPwrPluginUid;

    }

void CPwrPlugin::InitiateSamplerAttributesL()

    {

    // create TSamplerAttributes

    TSamplerAttributes attr(KSamplerPwrPluginUid.iUid,

            KPWRShortName(),

            KPWRLongName(),

            KPWRDescription(),

            250,

            EFalse,

            EFalse,

            0); 

    this->iSamplerAttributes->AppendL(attr);

    }

void CPwrPlugin::SetEnabled(TBool aEnabled)

    {

    iEnabled = aEnabled;

    }

// returns setting array

void CPwrPlugin::GetAttributesL(CArrayFixFlat<TSamplerAttributes>* aAttributes)

    {

    aAttributes->AppendL(iSamplerAttributes->At(0));

    }

TInt CPwrPlugin::SetAttributesL(TSamplerAttributes aAttributes)

    {

    TSamplerAttributes attr;

    attr = iSamplerAttributes->At(0);

    // replace the old attribute container

    iSamplerAttributes->Delete(0);

    iSamplerAttributes->InsertL(0, aAttributes);

    return KErrNone;

    }

/* 

 * Method for parsing and transforming text array settings into TSamplerAttributes (per each sub sampler),

 * called by CSamplerController class

 * 

 * @param array of raw text setting lines, e.g. [gpp]\nenabled=true\nsampling_period_ms=1\n

 */

TInt CPwrPlugin::ConvertRawSettingsToAttributes(CDesC8ArrayFlat* aAllSettingsArray)

    {

    // local literals

    _LIT8(KPWRShort, "pwr");

    TInt err(KErrNone);

    TBuf8<16> samplerSearchName;

    samplerSearchName.Copy(KPWRShort);

    // get sampler specific settings  

    err = DoSetSamplerSettings(aAllSettingsArray, samplerSearchName, 0);

    // returns KErrNone if settings found, otherwise KErrNotFound

    return err;

    }

TInt CPwrPlugin::DoSetSamplerSettings(CDesC8ArrayFlat* aAllSettings, TDesC8& aSamplerName, TInt aIndex)

    {

    // 

    TBuf8<16> samplerSearch;

    samplerSearch.Copy(KBracketOpen);

    samplerSearch.Append(aSamplerName);

    samplerSearch.Append(KBracketClose);

    // read a line

    for (TInt i(0); i<aAllSettings->MdcaCount(); i++)

        {

        // check if this line has a setting block start, i.e. contains [xxx] in it

        if (aAllSettings->MdcaPoint(i).CompareF(samplerSearch) == 0)

            {

            // right settings block found, now loop until the next block is found

            for(TInt j(i+1);j<aAllSettings->MdcaCount();j++)

                {

                // check if the next settings block was found

                if(aAllSettings->MdcaPoint(j).Left(1).CompareF(KBracketOpen) != 0)

                    {

                    // save found setting value directly to its owners attributes

                    SaveSettingToAttributes(aAllSettings->MdcaPoint(j), aIndex);

                    }

                else

                    {

                    // next block found, return KErrNone

                    return KErrNone;

                    }

                }

            }

        }

    return KErrNotFound;

    }

/**

 * Method for setting a specific descriptor (from settings file) to attribute structure

 * 

 * @param aSetting  

 * @param aName  

 */

void CPwrPlugin::SaveSettingToAttributes(const TDesC8& aSetting, TInt aIndex)

    {

    // find the equal mark from the setting line

    TInt sepPos = aSetting.Find(KSettingItemSeparator);

    // check that '=' is found

    if (sepPos > 0)

        {

        // check that the element matches

        if (aSetting.Left(sepPos).CompareF(KEnabled) == 0)

            {

            TBool en;

            CSamplerPluginInterface::Str2Bool(aSetting.Right(aSetting.Length()-sepPos-1), en);

            if(en != iSamplerAttributes->At(aIndex).iEnabled)

                {

                iSamplerAttributes->At(aIndex).iEnabled = en;

                }

            }

        else if (aSetting.Left(sepPos).CompareF(KSamplingPeriodMs) == 0)

            {

            TInt sr;

            CSamplerPluginInterface::Str2Int(aSetting.Right(aSetting.Length()-sepPos-1), sr);

            if(sr != iSamplerAttributes->At(aIndex).iSampleRate)

                {

                iSamplerAttributes->At(aIndex).iSampleRate = sr;

                }

            }

        }

    }

TInt CPwrPlugin::GetSamplerType()

    {

    return iSamplerType;

    }

TInt CPwrPlugin::ResetAndActivateL(CProfilerSampleStream& aStream) 

    {

    LOGTEXT(_L("CPwrPlugin::ResetAndActivate() - entry"));

    // check if sampler enabled

    if(iSamplerAttributes->At(0).iEnabled)

        {

        // create a new listener instance for every trace, destroy it on stop

        iPowerListener = CProfilerPowerListener::NewL(this);

        iStream = &aStream;

        TInt length = this->CreateFirstSample();

        iVersion[0] = (TUint8)length;

        LOGSTRING2("CPwrPlugin::ResetAndActivate() - AddSample, length %d", length);

        TInt ret = this->AddSample(iVersion, length+1, 0);

        LOGSTRING2("CPwrPlugin::ConstructL() - sampling period %d", this->iPeriod);

        HBufC8* iBufRes = HBufC8::NewMaxLC(10);

        TPtr8 iPtrRes = iBufRes->Des();

        // check if sampling rate set to something reasonable, relevant only in SYNC case

        if(iSamplerAttributes->At(0).iSampleRate != -1)

            {

            iPtrRes.Num(iSamplerAttributes->At(0).iSampleRate);

            }

        else

            {

            iPtrRes.Append(KNullDesC8);

            }

        // set disabled

        SetEnabled(ETrue); 

        // activate power listener

        ret = iPowerListener->StartL(iPtrRes);

        LOGTEXT(_L("CPwrPlugin::ResetAndActivate() - exit"));

        CleanupStack::PopAndDestroy();

        if(ret != KErrNone)

            return ret;

        }

    return KErrNone;

    }

TInt CPwrPlugin::CreateFirstSample() 

    {

    LOGTEXT(_L("CPwrPlugin::CreateFirstSample - entry"));

    this->iVersionDescriptor.Zero();

    this->iVersionDescriptor.Append(_L8("Bappea_PWR_V"));

    this->iVersionDescriptor.Append(PROFILER_PWR_SAMPLER_VERSION);

    LOGTEXT(_L("CPwrPlugin::CreateFirstSample - exit"));

    return (TInt)(this->iVersionDescriptor.Length());

    }

TInt CPwrPlugin::StopSampling() 

    {

    if(iPowerListener)

        {

        iPowerListener->Stop();

        delete iPowerListener;

        iPowerListener = NULL;

        }

    // set disabled

    SetEnabled(EFalse);

    return KErrNone;

    }

/*

 *

 * class CProfilerPowerListener implementation

 * 

 */

CProfilerPowerListener::CProfilerPowerListener(CPwrPlugin* aSampler) :

    iPwrSamplingPeriod(0),

    iOriginalReportingPeriod(0),

    iNominalCapa(0),

    iVoltage(0), 

    iCurrent(0),

    iPowerAPI(0)

#ifdef PWR_SAMPLER_BACKLIGHT

    ,iLightAPI(0),

    iBackLightStatus(CHWRMLight::ELightStatusUnknown)

#endif

    {

    LOGTEXT(_L("CProfilerPowerListener::CProfilerPowerListener() - konstuktori"));

    this->iSampler = aSampler;

    LOGTEXT(_L("CProfilerPowerListener::CProfilerPowerListener() - konstuktori exit"));

    }

CProfilerPowerListener* CProfilerPowerListener::NewL(CPwrPlugin* aSampler)

    {

    LOGTEXT(_L("CProfilerPowerListener::NewL() - entry"));

    CProfilerPowerListener* self = new (ELeave) CProfilerPowerListener(aSampler);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    LOGTEXT(_L("CProfilerPowerListener::NewL() - exit"));

    return self;

    }

void CProfilerPowerListener::ConstructL()

    {

    LOGTEXT(_L("CProfilerPowerListener::ConstructL() - entry"));

    iSampleStartTime = 0;

    LOGTEXT(_L("CProfilerPowerListener::ConstructL() - exit"));

    }

CProfilerPowerListener::~CProfilerPowerListener() 

    {

    LOGTEXT(_L("CProfilerPowerListener::~CProfilerPowerListener() - entry"));

    if (iPowerAPI)

        {

        delete iPowerAPI;

        iPowerAPI = 0;

        }

#ifdef PWR_SAMPLER_BACKLIGHT

    if (iLightAPI)

        {

        delete iLightAPI;

        iLightAPI = 0;

        }

#endif

    LOGTEXT(_L("CProfilerPowerListener::~CProfilerPowerListener() - exit"));

    }

TInt CProfilerPowerListener::DisplayNotifierL(const TDesC& aLine1, const TDesC& aLine2, const TDesC& aButton1, const TDesC& aButton2)

    {

    RNotifier notifier;

    TRequestStatus stat;

    TInt buttonValue(0);

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

    notifier.Notify(aLine1, aLine2, aButton1, aButton2, buttonValue, stat);

    User::WaitForRequest(stat);

    notifier.Close();

    return buttonValue;

    }

TInt CProfilerPowerListener::StartL(const TDesC8& aBuf)

    {

    LOGTEXT(_L("CProfilerPowerListener::StartL() - entry"));

    // get the property value

    TInt r = RProperty::Get(KGppPropertyCat, EGppPropertySyncSampleNumber, iSampleStartTime);

    if(r != KErrNone)

        {

        LOGSTRING2("CProfilerPowerListener::StartL() - getting iSyncOffset failed, error %d", r);

        }

   // check if given sampling period is valid

    if(aBuf.CompareF(KNullDesC8)!= 0)

        {

        TLex8* lex = new TLex8(aBuf);

        lex->Val(iPwrSamplingPeriod);

        delete lex;

        }

    else

        {

        // set default period

        iPwrSamplingPeriod = 250;

        }

    // Check that sampling period is in allowed range

    if (KMinSampleInterval > 0 && iPwrSamplingPeriod < KMinSampleInterval)

        {

        iPwrSamplingPeriod = KMinSampleInterval;

        }

    LOGSTRING2("CProfilerPowerListener::StartL() - Sampling period %d", iPwrSamplingPeriod);

    // Start monitoring voltage and current

    iPowerAPI = CHWRMPower::NewL();

    iPowerAPI->SetPowerReportObserver(this);

    // Read HWRM reporting settings from central repository

    CRepository* centRep = CRepository::NewL(KCRUidPowerSettings);

    TInt baseInterval(0);

    User::LeaveIfError(centRep->Get(KPowerBaseTimeInterval, baseInterval));

    User::LeaveIfError(centRep->Get(KPowerMaxReportingPeriod, iOriginalReportingPeriod));

    LOGSTRING2("CProfilerPowerListener::StartL() - HWRM base power report interval: %d", baseInterval);

    LOGSTRING2("CProfilerPowerListener::StartL() - Original HWRM max power reporting period: %d", iOriginalReportingPeriod);

    User::LeaveIfError(centRep->Set(KPowerMaxReportingPeriod, KReportingPeriodInfinite));

    // Power reporting interval reading may return too low value sometimes. Minimum value expected to be 250ms.

    if ( baseInterval < KMinSampleInterval )

        {

        baseInterval = KMinSampleInterval;

        LOGSTRING2("CProfilerPowerListener::StartL() - Power report interval too low. Changed to: %d", baseInterval);

        }

    // Power reporting period is multiplier of HWRM base period

    TInt intervalMultiplier = iPwrSamplingPeriod / baseInterval;

    if (intervalMultiplier < 1)

        {

        intervalMultiplier = 1;

        }

    LOGSTRING2("CProfilerPowerListener::StartL() - Reporting period multiplier: %d", intervalMultiplier);

    TRequestStatus status(KRequestPending);

    iPowerAPI->StartAveragePowerReporting(status, intervalMultiplier);

    User::WaitForRequest(status);

    if (status.Int() != KErrNone)

        {

        LOGTEXT(_L("CProfilerPowerListener::StartL() - Failed to initialize power reporting"));

        DisplayNotifierL(KPowerTextLine1, KPowerTextLine2, KButtonOk, KNullDesC);

        return status.Int();

        }

#ifdef PWR_SAMPLER_BACKLIGHT

    // Start monitoring backlight status

    iLightAPI = CHWRMLight::NewL(this);

#endif

    LOGTEXT(_L("CProfilerPowerListener::StartL() - exit"));

    return KErrNone;

    }

void CProfilerPowerListener::Sample()

    {

    LOGTEXT(_L("CProfilerPowerListener::Sample() - entry"));

    TRequestStatus status;

    CHWRMPower::TBatteryConsumptionData consumptionData;

    iPowerAPI->GetBatteryInfo(status, consumptionData);

    User::WaitForRequest(status);

    // Data is valid only if status == KErrNone 

    if (status.Int() != KErrNone)

        {

        LOGSTRING2("CProfilerPowerListener::Sample() - Getting battery info failed with code: ", status.Int());

        iNominalCapa = 0;

        }

    else

        {

        iNominalCapa = consumptionData.iNominalCapacity;

        }

    // Space for GPP sample time        

    //TUint32 sampleTime = iSampler->iStream->iSampler->GetSampleTime();

    TUint32 sampleTime = User::NTickCount() - iSampleStartTime;

    LOGSTRING2("CProfilerPowerListener::Sample() - Sample time: %d", sampleTime);

    LOGSTRING2("CProfilerPowerListener::Sample() - Nominal capacitance: %d", iNominalCapa);

    LOGSTRING2("CProfilerPowerListener::Sample() - Voltage: %d", iVoltage);

    LOGSTRING2("CProfilerPowerListener::Sample() - Current: %d", iCurrent);

#ifdef PWR_SAMPLER_BACKLIGHT

    LOGSTRING2("CProfilerPowerListener::Sample() - Backlight status: %d", (TUint8)iBackLightStatus);

#endif

    iSample[0] = iNominalCapa;

    iSample[1] = iNominalCapa >> 8;

    iSample[2] = iVoltage;

    iSample[3] = iVoltage >> 8;

    iSample[4] = iCurrent;

    iSample[5] = iCurrent >> 8;

    iSample[6] = iCurrent >> 16;

    iSample[7] = iCurrent >> 24;

#ifdef PWR_SAMPLER_BACKLIGHT

    iSample[8] = (TUint8)iBackLightStatus;

    iSample[9] = sampleTime;

    iSample[10] = sampleTime >> 8;

    iSample[11] = sampleTime >> 16;

    iSample[12] = sampleTime >> 24;

    iSampler->AddSample(iSample, 13, 0);

#else

    iSample[8] = sampleTime;