// Copyright (c) 2006-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 <centralrepository.h>

#include "HWRMtrace.h"

#include "HWRMPowerCommonData.h"

#include "HWRMClientServer.h"

#include "HWRMPowerDomainCRKeys.h"

#include "HWRMPrivateCRKeys.h"

#include "HWRMConfiguration.h"

#include "HWRMPowerService.h"

#include "HWRMPower.h"

#include "HWRMPowerService.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

const TInt KMilliToMicroSeconds = 1000;

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CHWRMPowerCommonData::CHWRMPowerCommonData

// C++ constructor

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

//

CHWRMPowerCommonData::CHWRMPowerCommonData()

	:iBatteryInfoQue(_FOFF(TBatteryInfoData,iSglQueLink)),

	iBatteryInfoIter(iBatteryInfoQue),

	iBatteryVoltageInfoQue(_FOFF(TBatteryInfoData,iSglQueLink)),

	iBatteryVoltageInfoIter(iBatteryVoltageInfoQue)

#ifdef SYMBIAN_HWRM_EXTPOWERINFO 

	,iChargerTypeInfoQue(_FOFF(TBatteryInfoData,iSglQueLink)),

	iChargerTypeInfoIter(iChargerTypeInfoQue)

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::CHWRMPowerCommonData()" ) );

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::CHWRMPowerCommonData - return" ) );

    }

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

// CHWRMPowerCommonData::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMPowerCommonData::ConstructL(CHWRMPluginHandler* aPluginHandler)

    {    

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::ConstructL()" ) );

    // Get read only values from cenrep

    iRepository = CRepository::NewL(KCRUidPowerSettings);

    iMaxReportingPeriodNotifyHandler = CCenRepListener::NewL(*this, 

                                                *iRepository, 

                                                KPowerMaxReportingPeriod);

    iMaxReportingPeriodNotifyHandler->StartListeningL();

    TInt value(0);

    User::LeaveIfError(iRepository->Get(KPowerBaseTimeInterval, value));

    if ( value < 1 )

        {

        User::Leave(KErrArgument);

        }

    iBaseTimeInterval = value * 1000;  // milliseconds to microseconds 

   	COMPONENT_TRACE2(_L( "HWRM Server - CHWRMPowerCommonData::ConstructL - iBaseTimeInterval: %d" ), iBaseTimeInterval );

    User::LeaveIfError(iRepository->Get(KPowerMaxReportingPeriod, value));

    if ( value < 1 )

        {

        User::Leave(KErrArgument);

        }

    iMaximumReportingPeriod = value * KMilliToMicroSeconds;  // milliseconds to microseconds 

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMPowerCommonData::ConstructL - iMaximumReportingPeriod: %d" ), iMaximumReportingPeriod );

    // Register for indications from HWRM plugin.

    aPluginHandler->RegisterForIndications(this);

    iPowerService = CHWRMPowerService::NewL(aPluginHandler, *this);

    iPowerReportMeasurementsTimer = CHWRMGenericTimer::NewL(*this, iMaximumReportingPeriod, EPowerReportClientsId);    

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    iChargingCurrentMeasurementsTimer = CHWRMGenericTimer::NewL(*this, iMaximumReportingPeriod, EChargingCurrentClientsId);

    //Timer should not be started for charging time measurements. So pass KHWRMGenericTimerMaxTime.

    iChargingTimeMeasurementsTimer = CHWRMGenericTimer::NewL(*this, KHWRMGenericTimerMaxTime, EChargingTimeClientsId);

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    iPowerReportClientsData = CClientsData::NewL(*iPowerReportMeasurementsTimer);

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    iChargingCurrentClientsData = CClientsData::NewL(*iChargingCurrentMeasurementsTimer);

    iChargingTimeClientsData = CClientsData::NewL(*iChargingTimeMeasurementsTimer);

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::ConstructL - return" ) );

    }

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

// CHWRMPowerCommonData::NewL

// Two-phased constructor.

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

//

CHWRMPowerCommonData* CHWRMPowerCommonData::NewL(CHWRMPluginHandler* aPluginHandler)

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::NewL()" ) );

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

    CleanupStack::PushL( self );

    self->ConstructL(aPluginHandler);

    CleanupStack::Pop();

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMPowerCommonData::NewL - return 0x%x" ), self );

    return self;

    }

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

// Destructor

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

//

CHWRMPowerCommonData::~CHWRMPowerCommonData()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::~CHWRMPowerCommonData()" ) );

    delete iPowerService;

    iPowerService = NULL;

    delete iRepository;  

    iRepository = NULL;

    delete iPowerReportClientsData;

    iPowerReportClientsData = NULL;

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    delete iChargingCurrentClientsData;

    iChargingCurrentClientsData = NULL;

    delete iChargingTimeClientsData;

    iChargingTimeClientsData = NULL;

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    if (iPowerReportMeasurementsTimer)

        {

        iPowerReportMeasurementsTimer->Cancel();

        delete iPowerReportMeasurementsTimer;

        iPowerReportMeasurementsTimer = NULL;

        }

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    if(iChargingCurrentMeasurementsTimer)

        {

        iChargingCurrentMeasurementsTimer->Cancel();

        delete iChargingCurrentMeasurementsTimer;

        iChargingCurrentMeasurementsTimer = NULL;

        }

    if (iChargingTimeMeasurementsTimer)

        {

        iChargingTimeMeasurementsTimer->Cancel();

        delete iChargingTimeMeasurementsTimer;

        iChargingTimeMeasurementsTimer = NULL;

        }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	TBatteryInfoData*  batteryInfoData;

	iBatteryInfoIter.SetToFirst();

    while((batteryInfoData = iBatteryInfoIter++) != NULL)

        {

        iBatteryInfoQue.Remove(*batteryInfoData);

        delete batteryInfoData;

        }

	iBatteryVoltageInfoIter.SetToFirst();

    while((batteryInfoData = iBatteryVoltageInfoIter++) != NULL)

        {

        iBatteryVoltageInfoQue.Remove(*batteryInfoData);

        delete batteryInfoData;

        }

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    iChargerTypeInfoIter.SetToFirst();

    while((batteryInfoData = iChargerTypeInfoIter++) != NULL)

        {

        iChargerTypeInfoQue.Remove(*batteryInfoData);

        delete batteryInfoData;

        }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::~CHWRMPowerCommonData - return" ) );

    }

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

// CHWRMPowerCommonData::ProcessIndicationL

// Callback function From MHWRMIndicationHandler

// Called by the plugin handler to indicate that a new 

// measurement report is ready

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

//

void CHWRMPowerCommonData::ProcessIndicationL( const TUint32 aId, TDesC8& aData )

	{

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::ProcessIndicationL()" ) );

	switch (aId)

		{

        case HWRMPowerCommand::EAverageBatteryPowerIndicationId:

			{

			if (iPowerReportClientsData->IsMeasuringOn())

				{

				HWRMPowerCommand::TBatteryPowerReportPackage batteryPowerReportPckg;

				batteryPowerReportPckg.Copy(aData);

				HWRMPowerCommand::TBatteryPowerReport batteryPowerReport = batteryPowerReportPckg();

				if (batteryPowerReport.iErrorCode == KErrNone)

					{					

					iPowerReportClientsData->BatteryMeasurementIndicationL(batteryPowerReportPckg);

					}

				}

			}

		break;

		#ifdef SYMBIAN_HWRM_EXTPOWERINFO

        case HWRMPowerCommand::EAverageBatteryChargingCurrentIndicationId:

			{

			if (iChargingCurrentClientsData->IsMeasuringOn())

				{

				HWRMPowerCommand::TBatteryChargingCurrentReportPackage batteryChargeCurrentReportPckg;

				batteryChargeCurrentReportPckg.Copy(aData);

				HWRMPowerCommand::TBatteryChargeCurrentReport batteryChargeCurrentReport= batteryChargeCurrentReportPckg();

				if (batteryChargeCurrentReport.iErrorCode == KErrNone)

					{

					iChargingCurrentClientsData->BatteryMeasurementIndicationL(batteryChargeCurrentReportPckg);

					}

				}

			}

		break;

        case HWRMPowerCommand::EBatteryFullChargingTimeIndicationId:

            {

			if (iChargingTimeClientsData->IsMeasuringOn())

				{

				HWRMPowerCommand::TBatteryFullChargingTimeReportPackage batteryChargeTimePckg;

				batteryChargeTimePckg.Copy(aData);

				HWRMPowerCommand::TBatteryFullChargingTimeReport batteryChargeTimeReport= batteryChargeTimePckg();

				if (batteryChargeTimeReport.iErrorCode == KErrNone)

					{

					iChargingTimeClientsData->BatteryMeasurementIndicationL(batteryChargeTimePckg);

					}

				}

			}

        break;

#endif //SYMBIAN_HWRM_EXTPOWERINFO

		}	

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::EventIndicationL - return" ) );

	}

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

// CHWRMPowerCommonData::GenericTimerFired

// Callback function From MHWRMGenericTimerCallback

// Called when the timer is fired. The PowerCommonData

// hold two of them one for Voltage, one for Consumption 

// Measurements. Informs clients, cleans up and stops the 

// plugin.

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

//

void CHWRMPowerCommonData::GenericTimerFired(TInt aTimerId, TBool /*aCutOff*/)

	{

	TInt err(KErrNone);

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::GenericTimerFired()" ) );

	switch(aTimerId)

		{

        case EPowerReportClientsId:

			{

			iPowerReportClientsData->MaxReportingPeriodReached();

			TRAP(err, DoStopPowerMeasurementsL());

			break;

			}

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

        case EChargingCurrentClientsId:

            {

            iChargingCurrentClientsData->MaxReportingPeriodReached();

            TRAP(err,DoStopChargingCurrentMeasurementsL());

            break;

            }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

		}

	if (err != KErrNone)

		{

		// All the pending batch request have been completed now.

		// Also plugin will not send any more measurements.

		COMPONENT_TRACE3(_L( "HWRM Server - CHWRMPowerCommonData::GenericTimerFired(%d) - Stopping measurement failed: %d" ), aTimerId, err );

		}

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::GenericTimerFired - return" ) );

	}

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

// CHWRMPowerCommonData::DoStopPowerMeasurementsL

// Issues a plugin command to stop the Power measurements.

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

//

void CHWRMPowerCommonData::DoStopPowerMeasurementsL()

	{

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::DoStopPowerMeasurementsL()" ) );

	iPowerService->StopPowerMeasurementsL();

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::DoStopPowerMeasurementsL - return" ) );

	}

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

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

// CHWRMPowerCommonData::DoStopChargingCurrentMeasurementsL

// Issues a plugin command to stop the Charging current measurements.

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

//

void CHWRMPowerCommonData::DoStopChargingCurrentMeasurementsL()

	{

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::DoStopChargingCurrentMeasurementsL()" ) );

	iPowerService->StopChargingCurrentMeasurementsL();

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::DoStopChargingCurrentMeasurementsL - return" ) );

	}

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

// CHWRMPowerCommonData::DoStopChargingTimeMeasurementsL

// Issues a plugin command to stop BatteryFull charging time measurement.

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

//

void CHWRMPowerCommonData::DoStopChargingTimeMeasurementsL()

	{

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::DoStopChargingTimeMeasurementsL()" ) );

	iPowerService->StopChargingTimeMeasurementsL();

	COMPONENT_TRACE1(_L( "HWRM Server - CHWRMPowerCommonData::DoStopChargingTimeMeasurementsL - return" ) );

	}

#endif //SYMBIAN_HWRM_EXTPOWERINFO

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

// CHWRMPowerCommonData::DoMaxReportingValueChanged

// Handles the max reporting period cenrep value changes for all measurements.

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

void CHWRMPowerCommonData::MaxPeriodChangedL(TTimeIntervalMicroSeconds32& aNewMaxPeriod,

                           TTimeIntervalMicroSeconds32& aOldMaxPeriod)

    {

    DoMaxReportingValueChangedL(iPowerReportMeasurementsTimer, aNewMaxPeriod, aOldMaxPeriod);

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    DoMaxReportingValueChangedL(iChargingCurrentMeasurementsTimer, aNewMaxPeriod, aOldMaxPeriod);

    DoMaxReportingValueChangedL(iChargingTimeMeasurementsTimer, aNewMaxPeriod, aOldMaxPeriod);

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    }

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

// CHWRMPowerCommonData::DoMaxReportingValueChangedL

// Handles the max reporting period cenrep value changes.

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

void CHWRMPowerCommonData::DoMaxReportingValueChangedL(CHWRMGenericTimer* aTimer, 

                                                      TTimeIntervalMicroSeconds32& aNewMaxPeriod,

                                                      TTimeIntervalMicroSeconds32& aOldMaxPeriod)

    {    

    /*

    * Timer Usage:

    * aTimer->IsActive()  : Checks if timer is running(active, which means measurement is going on.)

    * aTimer->Freeze()    : Stop the timer.

    * aTimer->GetTimerId(): Get the measurement(power,charging,..) corresponding to timer.

    * aTimer->RunL()      : Calls CHWRMPowerCommonData::GenericTimerFired, which stops the measurements.

    *

    * - If new max reporting period is negative, complete pending measurement with KErrGeneral and stop the measurements.

    * - If timer is not running, just set the timer.

    * - If new max reporting period is zero, stop the timer if running and measurements will go on for infinite duration.

    * - If new max reporting period is more than elapsed time, stop current time and start for remaining time(Max-elapsed).

    * - If new max reporting period is less than elapsed time, complete pending measurement with KErrTimedOut and stop the measurements.

    */

    #ifdef _DEBUG

    _LIT(KHWRMPowerCommonDataPanic,"CHWRMPowerCommonData");

    #endif      

    __ASSERT_DEBUG((aTimer)!=NULL, User::Panic(KHWRMPowerCommonDataPanic,KErrBadHandle));

    if(aNewMaxPeriod.Int() < 0)

        {

        if(aTimer->IsActive())

            {

            //Cenrep value is negative, Inform client that timer has expired.

            aTimer->Freeze();

            switch(aTimer->GetTimerId())

                {

                case EPowerReportClientsId:

            		{

            		iPowerReportClientsData->MaxReportingPeriodReached(KErrGeneral);

            		break;

            		}

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

                case EChargingCurrentClientsId:

                    {

                    iChargingCurrentClientsData->MaxReportingPeriodReached(KErrGeneral);

                    break;

                    }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

                }

            aTimer->RunL();

            }

        }

    else

        {

        iMaximumReportingPeriod = aNewMaxPeriod.Int();

        aTimer->SetMaximumTime(aNewMaxPeriod);

        if(aOldMaxPeriod.Int() == 0)

            {

            aTimer->Set(aNewMaxPeriod);

            }

    	else if(aTimer->IsActive())

    		{

    		if(aNewMaxPeriod.Int() == 0)

    			{

    			//Stop Timer and don't Start Timer

    			aTimer->Freeze();

    			}

    		else

    			{

    			//Ex: If aOldMaxPeriod=8sec, aNewMaxPeriod=10sec, 

    			// elapsedTime=4sec, start timer with 6sec.

                //Freeze will stop the timer and return remaining time.

    			TTimeIntervalMicroSeconds32 remainingTime = aTimer->Freeze();

    			TTimeIntervalMicroSeconds32 elapsedTime;

    			elapsedTime = aOldMaxPeriod.Int() - remainingTime.Int();

    			if(aNewMaxPeriod > elapsedTime)

    				{

    				//Start a new Timer.

    				aTimer->Set((aNewMaxPeriod.Int() - elapsedTime.Int()));

    				}

                else

                    {

                    //Inform Client that Timer has expired.

                    aTimer->Freeze();

                    aTimer->RunL();

                    }

    			}

            }

        }

    }

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