TBool CPerfMonPowerListener::iIsSupported = ETrue;

/*

 *

 * class CPerfMonPowerListener implementation

 * 

 */

CPerfMonPowerListener* CPerfMonPowerListener::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

CPerfMonPowerListener::CPerfMonPowerListener() :

    iPowerListenerImpl(NULL)

    {

    }

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

void CPerfMonPowerListener::ConstructL()

    {

    TRAPD(err, iPowerListenerImpl = CPerfMonPowerListenerImpl::NewL());

    if (err != KErrNone)

        iPowerListenerImpl = NULL;

        // Could not initialize power monitoring client. Feature support not available.

        iIsSupported = EFalse;

    }

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

CPerfMonPowerListener::~CPerfMonPowerListener()

    {

    DeActivate();

    if (iPowerListenerImpl)

        delete iPowerListenerImpl;

        iPowerListenerImpl = 0;

    }

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

TInt CPerfMonPowerListener::Activate()

    { 

    if (iPowerListenerImpl)

        return iPowerListenerImpl->Activate();

    else

    }

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

void CPerfMonPowerListener::DeActivate()

    {

    if (iPowerListenerImpl)

        {

        iPowerListenerImpl->DeActivate();

        }

    }

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

TInt CPerfMonPowerListener::GetPower()

    {

    if (iPowerListenerImpl)

        return iPowerListenerImpl->GetPower();

    else

        {

        return 0;

        }

    }

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

TInt CPerfMonPowerListener::GetMaxPower()

    {

    if (iPowerListenerImpl)

        {

        return iPowerListenerImpl->GetMaxPower();

        }

    else

    }

/*

 *

 * class CPerfMonPowerListenerImpl implementation

 * 

 */

CPerfMonPowerListenerImpl* CPerfMonPowerListenerImpl::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

CPerfMonPowerListenerImpl::CPerfMonPowerListenerImpl() :

    iHWRMPower(NULL),

    iLastPowerAvg(0),

    iMaxPower(0),

    iOriginalMaxReportingPeriod(0)

    {

    }

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

void CPerfMonPowerListenerImpl::ConstructL()

    {

    iHWRMPower = CHWRMPower::NewL();

    // Callbacks to this object

    User::LeaveIfError(iHWRMPower->SetPowerReportObserver(this));

    iOriginalMaxReportingPeriod = GetReportingPeriodL();

    }

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

CPerfMonPowerListenerImpl::~CPerfMonPowerListenerImpl()

    {

    DeActivate();

    if (iHWRMPower)

        delete iHWRMPower;

        iHWRMPower = 0;

        }

    }

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

TInt CPerfMonPowerListenerImpl::Activate()

    {

    // Set infinite reporting period

    TRAPD(err, SetReportingPeriodL(KHWRMReportingDuration));

    if (err != KErrNone)

        {

        return err;

        }

    TRequestStatus status(KRequestPending);

    // Start the power consumption notification

    iHWRMPower->StartAveragePowerReporting(status, KHWRMSampleIntervalMultiple);

    User::WaitForRequest(status);

    // Check if monitoring was succesfully started or already ongoing.

    if ((status.Int() != KErrNone) && (status.Int() != KErrAlreadyExists))

        {

        return status.Int();

        }

    return KErrNone;

    }

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

void CPerfMonPowerListenerImpl::DeActivate()

    {

    if (iHWRMPower)

        {

        TRAP_IGNORE(iHWRMPower->StopAveragePowerReportingL());

    // Restore original value to max sampling duration

    TRAP_IGNORE(SetReportingPeriodL(iOriginalMaxReportingPeriod));

    iPowerBuffer.Reset();

    iLastPowerAvg = 0;

    }

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

TInt CPerfMonPowerListenerImpl::GetPower()

    {

    TInt avgPower = 0;

    TInt newValueCount = iPowerBuffer.Count();

    if (newValueCount > 0)

        {

        // Read all new values from buffer and calculate average from them.

        for (int i = 0; i < newValueCount; i++)

            {

            avgPower += iPowerBuffer[i];

            }

        avgPower = avgPower / newValueCount;

        iPowerBuffer.Reset();

        iLastPowerAvg = avgPower;

        }

    // Use previous value if no new data has been reported since previous call.

    // This may happen since perfmon sampling and power reporting are not synchronized.

    else

        {

        avgPower = iLastPowerAvg;

        }

    return avgPower;

    }

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

void CPerfMonPowerListenerImpl::PowerMeasurement(TInt aErrCode, CHWRMPower::TBatteryPowerMeasurementData& aMeasurement)

    {

    if (aErrCode == KErrNone)

        {

        // Calculate power value

        TInt value = aMeasurement.iAverageVoltage * aMeasurement.iAverageCurrent;

        // If charger is connected, reported values may be negative.

        if (value < 0)

            {

            value = 0;

            }

        // Store new value to buffer to wait for reading

        iPowerBuffer.Append(value);

        if ( value > iMaxPower )

            {

            iMaxPower = value;

            }

        }

    // Ignore any reports containing error information

    }

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

TInt CPerfMonPowerListenerImpl::GetReportingPeriodL()

    {

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

    CleanupStack::PushL(cenRep);

    TInt reportingPeriod(0);

    User::LeaveIfError(cenRep->Get(KPowerMaxReportingPeriod, reportingPeriod));

    CleanupStack::PopAndDestroy();

    return reportingPeriod;

    }

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

void CPerfMonPowerListenerImpl::SetReportingPeriodL(TInt aDuration)

    {

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

    CleanupStack::PushL(cenRep);

    User::LeaveIfError(cenRep->Set(KPowerMaxReportingPeriod, aDuration));

    CleanupStack::PopAndDestroy();

    }