/*
 * 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_powerlistener.h"
#include "../../symbian_version.hrh"

#include <centralrepository.h>
#include <hwrm/hwrmpowerdomaincrkeys.h>


#if (SYMBIAN_VERSION_SUPPORT == SYMBIAN_3)

    CPerfMonPowerListener* CPerfMonPowerListener::NewL()
        {
        CPerfMonPowerListener* self = new (ELeave) CPerfMonPowerListener();
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop();
        return self;
        }

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

    CPerfMonPowerListener::CPerfMonPowerListener() :
        iHWRMPower(0),
        iLastPowerAvg(0),
        iMaxPower(0),
        iOriginalMaxReportingPeriod(0)
        {
        }

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

    void CPerfMonPowerListener::ConstructL()
        {
        }

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

    CPerfMonPowerListener::~CPerfMonPowerListener()
        {
        DeActivate();
        
        if (iHWRMPower != 0)
            {
            delete iHWRMPower;
            iHWRMPower = 0;
            }
        }

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

    TBool CPerfMonPowerListener::IsSupported()
        {
        return ETrue;
        }

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

    TInt CPerfMonPowerListener::Activate()
        {
        if (iHWRMPower == 0)
            {
            TRAPD(err, iHWRMPower = CHWRMPower::NewL());
            if (err != KErrNone)
                {
                return err;
                }

            // Callbacks to this object
            err = iHWRMPower->SetPowerReportObserver(this);
            if (err != KErrNone)
                {
                return err;
                }
            
            TRAP_IGNORE(GetReportingPeriodL());
            }

        // Set infinite reporting period
        TRAPD(err, SetReportingPeriodL(KReportingDuration));
        if (err != KErrNone)
            {
            return err;
            }

        TRequestStatus status(KRequestPending);

        // Start the power consumption notification
        iHWRMPower->StartAveragePowerReporting(status, KSampleIntervalMultiple);
        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 CPerfMonPowerListener::DeActivate()
        {
        if (iHWRMPower != 0)
            {
            TRAP_IGNORE(iHWRMPower->StopAveragePowerReportingL());
            }

        // Restore original value to max sampling duration
        TRAP_IGNORE(SetReportingPeriodL(iOriginalMaxReportingPeriod));

        iPowerBuffer.Reset();
        iLastPowerAvg = 0;
        }

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

    TInt CPerfMonPowerListener::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;
            }
        else
            {
            avgPower = iLastPowerAvg;
            }

        return avgPower;
        }

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

    void CPerfMonPowerListener::PowerMeasurement(TInt aErrCode, CHWRMPower::TBatteryPowerMeasurementData& aMeasurement)
        {
        if (aErrCode == KErrNone)
            {
            // Store new value to buffer to wait for reading
            TInt value = aMeasurement.iAverageVoltage * aMeasurement.iAverageCurrent;

            // If charger is connected, reported values may be negative.
            if (value < 0)
                {
                value = 0;
                }

            iPowerBuffer.Append(value);

            if ( value > iMaxPower )
                {
                iMaxPower = value;
                }
            }
        // Ignore any errors
        }

    void CPerfMonPowerListener::GetReportingPeriodL()
        {
        CRepository* cenRep = CRepository::NewL(KCRUidPowerSettings);

        CleanupStack::PushL(cenRep);
        User::LeaveIfError(cenRep->Get(KPowerMaxReportingPeriod, iOriginalMaxReportingPeriod));
        CleanupStack::Pop();

        delete cenRep;
        }

    void CPerfMonPowerListener::SetReportingPeriodL(TInt aDuration)
        {
        CRepository* cenRep = CRepository::NewL(KCRUidPowerSettings);

        CleanupStack::PushL(cenRep);
        User::LeaveIfError(cenRep->Set(KPowerMaxReportingPeriod, aDuration));
        CleanupStack::Pop();
        
        delete cenRep;
        }

// SYMBIAN_VERSION_SUPPORT < SYMBIAN_3
#else

    // Stub implementation for older Symbian versions

    CPerfMonPowerListener* CPerfMonPowerListener::NewL()
        {
        CPerfMonPowerListener* self = new (ELeave) CPerfMonPowerListener();
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop();
        return self;
        }

    CPerfMonPowerListener::CPerfMonPowerListener() :
        iHWRMPower(0),
        iLastPowerAvg(0),
        iMaxPower(0)
        {
        }

    void CPerfMonPowerListener::ConstructL()
        {
        }

    CPerfMonPowerListener::~CPerfMonPowerListener()
        {
        DeActivate();
        }

    TBool CPerfMonPowerListener::IsSupported()
        {
        return EFalse;
        }

    TInt CPerfMonPowerListener::Activate()
        {
        return KErrNotSupported;
        }

    void CPerfMonPowerListener::DeActivate()
        {
        }

    TInt CPerfMonPowerListener::GetPower()
        {
        return 0;
        }

    void CPerfMonPowerListener::PowerMeasurement(TInt aErrCode, CHWRMPower::TBatteryPowerMeasurementData& aMeasurement)
        {
        }

#endif

// End of File