// Copyright (c) 2008-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 <e32svr.h>

#include "HWRMBatteryPowerMeasurementsAO.h"

#include "HWRMPowerClientServer.h"

#include "HWRMtrace.h"

#include "HWRMClient.h"

#include "HWRMPowerImpl.h"

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

#include "HWRMBatteryChargeCurrentRateAO.h"

#include "HWRMBatteryChargeTimeMeasurementsAO.h"

#include "HWRMChargingStatusObserver.h"

#endif //SYMBIAN_HWRM_EXTPOWERINFO

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CHWRMPowerImpl::NewL

// Two-phased constructor.

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

//

CHWRMPowerImpl* CHWRMPowerImpl::NewL()

	{

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::NewL()"));

    CHWRMPowerImpl* powerImpl = new( ELeave ) CHWRMPowerImpl();

    CleanupStack::PushL( powerImpl );        

    powerImpl->ConstructL();        

    CleanupStack::Pop(); 

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::NewL - return" ));

    return powerImpl;

	}

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

// CHWRMPowerImpl::CHWRMPowerImpl

// C++ constructor

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

//

CHWRMPowerImpl::CHWRMPowerImpl()

	:iBatteryConsumptionDataPckg(NULL, 0, 0),

	iBatteryVoltageDataPckg(NULL, 0, 0),

	iPowerIntervalMultiplePckg(NULL,0,0)	

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

	,iBatteryChargerTypePckg(NULL, 0, 0),

	iChargingStatusImpl(NULL),

	iCurrentRateIntervalMultiplePckg(NULL,0,0)

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	{	

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::CHWRMPowerImpl()"));

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::CHWRMPowerImpl - return" ));

	}

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

// Destructor

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

//

CHWRMPowerImpl::~CHWRMPowerImpl()

	{

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::~CHWRMPowerImpl()" ));

	Close();	

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    iBatteryChargeCurrentRateAO = NULL;

    iBatteryChargingTimeAO = NULL;

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::~CHWRMPowerImpl - return" ));

	}

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

// CHWRMPowerImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMPowerImpl::ConstructL()

	{

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::ConstructL()" ));

	OpenL();

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::ConstructL - return" ) );    

	}

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

// CHWRMPowerImpl::OpenL

// Opens session

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

//

void CHWRMPowerImpl::OpenL()

    {

    COMPONENT_TRACE1( _L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Open()" ));

    User::LeaveIfError(iClient.Connect(HWRMResourceTypePower));

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Open - Craeting Active objects for measurements reporting" ));

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    //Create observer here, so that charging current/time notification can be stopped,

    //if charger is disconnected.

    iChargingStatusImpl = CHWRMChargingStatusObs::NewL(this);

#endif //SYMBIAN_HWRM_EXTPOWERINFO

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Open - return" ));

    }

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

// CHWRMPowerImpl::Close

// Closes session.

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

//

void CHWRMPowerImpl::Close()

	{

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close()" ));

    if ( iBatteryPowerMeasurementsAO)

		{

		COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close - canceling BatteryPowerMeasurements notifications" ));

		delete iBatteryPowerMeasurementsAO;

		iBatteryPowerMeasurementsAO = NULL;

		}

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

        delete iChargingStatusImpl;

        iChargingStatusImpl = NULL;

        COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close Deleted iChargingStatusImpl" ));        

        delete iBatteryChargeCurrentRateAO;

        iBatteryChargeCurrentRateAO = NULL;

        delete iBatteryChargingTimeAO;

        iBatteryChargingTimeAO = NULL;

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	// Inform session that we are cleaning up now.

	// Ignore errors, just trace them

	if (iClient.Handle())

		{

		iClient.ExecuteOperation(EHWRMCleanupBattery, TIpcArgs());

        }

    iClient.Close();

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close - return" ) );

    }    

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

// CHWRMPowerImpl::DoGetBatteryInfo

// 

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

//

void CHWRMPowerImpl::DoGetBatteryInfo(TRequestStatus& aStatus, CHWRMPower::TBatteryConsumptionData& aBatteryConsumptionData )

	{

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryInfo()" ));

	iBatteryConsumptionDataPckg.Set( TPckg<CHWRMPower::TBatteryConsumptionData> (aBatteryConsumptionData) );

	iClient.ExecuteAsyncOperation(EHWRMGetBatteryInfo, TIpcArgs(&iBatteryConsumptionDataPckg), aStatus);

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryInfo - return" ));

	}

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

// CHWRMPowerImpl::DoGetVoltageInfo

// 

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

//

void CHWRMPowerImpl::DoGetBatteryVoltageInfo(TRequestStatus& aStatus, CHWRMPower::TBatteryVoltageData& aBatteryVoltageData)

	{

	COMPONENT_TRACE1(_L( "HWRM PowerClient - CHWRMPowerImpl::DoGetBatteryVoltageInfo()" ));

	iBatteryConsumptionDataPckg.Set( TPckg<CHWRMPower::TBatteryVoltageData> (aBatteryVoltageData) );

	iClient.ExecuteAsyncOperation(EHWRMGetBatteryVoltageInfo, TIpcArgs(&iBatteryConsumptionDataPckg), aStatus);

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryVoltageInfo - return" ));

	}

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

// CHWRMPowerImpl::DoStartAveragePowerReporting

// 

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

//

TInt CHWRMPowerImpl::DoStartAveragePowerReporting(TRequestStatus& aStatus, const TUint& aInterval)

	{	

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStartAveragePowerReporting()" ));

	if (!iBatteryPowerMeasurementsAO)

		{

		COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStartAveragePowerReporting - return( - return 0x%x" ), KErrBadHandle );

		return KErrBadHandle;

		}

	else 

		{		

		iPowerIntervalMultiplePckg.Set( TPckg<TUint> (aInterval) );

		iClient.ExecuteAsyncOperation(EHWRMStartAverageBatteryPowerReporting, TIpcArgs(&iPowerIntervalMultiplePckg), aStatus);

		//Issue request to retrieve battery power measurements	

		if( !iBatteryPowerMeasurementsAO->IsActive())

			{

			iBatteryPowerMeasurementsAO->GetAsyncBatch( EHWRMGetPowerMeasurements );	

			}		

		COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStartAveragePowerReporting - return( - return 0x%x" ), KErrNone );

	    return KErrNone;

		}

	}

void CHWRMPowerImpl::DoStopAveragePowerReportingL()

	{	

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStopAveragePowerReportingL()" ));

	if (iBatteryPowerMeasurementsAO)

		{

		COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close - canceling BatteryPowerMeasurements notifications" ));

		iBatteryPowerMeasurementsAO->Cancel();		

		User::LeaveIfError(iClient.ExecuteOperation(EHWRMStopAverageBatteryPowerReporting, TIpcArgs()));

		}

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStopAveragePowerReportingL - return" ));

	}

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

// CHWRMPowerImpl::DoSetPowerReportObserverL

// 

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

//

void CHWRMPowerImpl::DoSetPowerReportObserverL(MHWRMBatteryPowerObserver* aPowerReportCallback)

    {

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoSetPowerReportObserverL()" ));

    if(aPowerReportCallback)

        {

        if(iBatteryPowerMeasurementsAO)

            {

            iBatteryPowerMeasurementsAO->SetCallBack(aPowerReportCallback);

            }

        else

            {

            iBatteryPowerMeasurementsAO = CHWRMBatteryPowerMeasurementsAO::NewL(aPowerReportCallback, iClient);

            }

        COMPONENT_TRACE1(_L( "iBatteryPowerMeasurementsAO Created" ));    

        }

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoSetPowerReportObserverL - return" ));

    }

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

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

// CHWRMPowerImpl::DoGetBatteryChargerType

// 

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

//

TInt CHWRMPowerImpl::DoGetBatteryChargerType(CHWRMPower::TBatteryChargerType& aChargerType)

    {

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryChargerType()" ));

	iBatteryChargerTypePckg.Set( TPckg<CHWRMPower::TBatteryChargerType> (aChargerType) );

	TInt err = iClient.ExecuteOperation(EHWRMGetBatteryChargerType, TIpcArgs(&iBatteryChargerTypePckg));

    COMPONENT_TRACE3(_L( "HWRM CHWRMPowerImpl - Charger Type = %d err = %d" ), aChargerType, err);    

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryChargerType - return" ));

    return err;

	}

TInt CHWRMPowerImpl::DoGetBatteryChargingStatus(CHWRMPower::TBatteryChargingStatus& aChargingStatus)

    {

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryChargingStatus()" ));

    TInt val;

    aChargingStatus = CHWRMPower::EChargingStatusError;

    TInt err = iChargingStatusImpl->Get(val);

    if(err == KErrNone)

        {

        aChargingStatus = static_cast<CHWRMPower::TBatteryChargingStatus>(val);

        }

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoGetBatteryChargingStatus - return" ));

    return err;

    }

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

// CHWRMPowerImpl::DoSetBatteryChargingObserver

// 

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

//

void CHWRMPowerImpl::DoSetBatteryChargingObserverL(

             MHWRMBatteryChargingStatusObserver*   aChargingStatusCallback,

             MHWRMBatteryChargingCurrentObserver*     aChrgCurrentCallback,

             MHWRMBatteryFullChargingTimeObserver* aChrgTimeCallback)

    {

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoSetBatteryChargingObserver()" ));

    if(aChargingStatusCallback)

        {

        iChargingStatusClientObserver = aChargingStatusCallback;

        COMPONENT_TRACE1(_L( "iChargingStatusImpl Created" ));        

        }

    if(aChrgCurrentCallback)

        {

        if(iBatteryChargeCurrentRateAO)

            {

            iBatteryChargeCurrentRateAO->SetCallBack(aChrgCurrentCallback);

            }

        else

            {

            iBatteryChargeCurrentRateAO = CHWRMBatteryChargeRateCurrentAO::NewL(aChrgCurrentCallback, iClient);

            }

        COMPONENT_TRACE1(_L( "iBatteryChargeCurrentRateAO Created" ));    

        }

    if(aChrgTimeCallback)

        {

        if(iBatteryChargingTimeAO)

            {

            iBatteryChargingTimeAO->SetCallBack(aChrgTimeCallback);

            }

        else

            {

            iBatteryChargingTimeAO = CHWRMBatteryChargeTimeMeasurementsAO::NewL(aChrgTimeCallback, iClient);

            }

        COMPONENT_TRACE1(_L( "iBatteryChargingTimeAO Created" ));    

        }

    COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoSetBatteryChargingObserver - return" ));

    }

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

// CHWRMPowerImpl::DoNotifyAverageChargingCurrent

// 

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

//

TInt CHWRMPowerImpl::DoNotifyAverageChargingCurrent(TRequestStatus& aStatus, const TUint& aInterval)

    {	

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyAverageChargingCurrent()" ));

	if (!iBatteryChargeCurrentRateAO)

		{

		COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyAverageChargingCurrent - return( - return 0x%x" ), KErrBadHandle );

		return KErrBadHandle;

		}

    TInt err(KErrNone);

    CHWRMPower::TBatteryChargingStatus chargingStatus;

    err = DoGetBatteryChargingStatus(chargingStatus);

    if((err != KErrNone) || 

       (chargingStatus == CHWRMPower::EChargingStatusError) || 

       (chargingStatus == CHWRMPower::EChargingStatusNotConnected) || 

       (chargingStatus == CHWRMPower::EChargingStatusNotCharging))

        {

        err = KErrNotReady;

        }

	else 

		{		

		iCurrentRateIntervalMultiplePckg.Set( TPckg<TUint> (aInterval) );

		iClient.ExecuteAsyncOperation(EHWRMStartAverageChargingCurrentReporting, TIpcArgs(&iCurrentRateIntervalMultiplePckg), aStatus);

		//Issue request to retrieve battery voltage measurements	

		if( !iBatteryChargeCurrentRateAO->IsActive())

			{

			iBatteryChargeCurrentRateAO->GetAsyncBatch( EHWRMGetAverageChargingCurrentMeasurements );	

			}		

        err = KErrNone;

		}

    COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyAverageChargingCurrent - return( - return 0x%x" ), err );

    return err;

	}

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

// CHWRMPowerImpl::DoNotifyBatteryFullChargingTime

// 

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

//

TInt CHWRMPowerImpl::DoNotifyBatteryFullChargingTime(TRequestStatus& aStatus)

    {	

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyBatteryFullChargingTime()" ));

	if (!iBatteryChargingTimeAO)

		{

		COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyBatteryFullChargingTime - return( - return 0x%x" ), KErrBadHandle );

		return KErrBadHandle;

		}

    TInt err;

    CHWRMPower::TBatteryChargingStatus chargingStatus;

    err = DoGetBatteryChargingStatus(chargingStatus);

    if((err != KErrNone) || 

       (chargingStatus == CHWRMPower::EChargingStatusError) || 

       (chargingStatus == CHWRMPower::EChargingStatusNotConnected) || 

       (chargingStatus == CHWRMPower::EChargingStatusNotCharging))

        {

        err = KErrNotReady;

        }

	else 

		{		

		iClient.ExecuteAsyncOperation(EHWRMStartBatteryFullChargingTimeReporting, TIpcArgs(), aStatus);

		//Issue request to retrieve battery full charge time measurements	

		if( !iBatteryChargingTimeAO->IsActive())

			{

			iBatteryChargingTimeAO->GetAsyncBatch( EHWRMGetBatteryFullChargingTimeMeasurements );	

			}		

	    err = KErrNone;        

		}

    COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoNotifyBatteryFullChargingTime - return( - return 0x%x" ), err );

    return err;

	}

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

// CHWRMPowerImpl::DoStopChargingNotificationL

// 

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

//

void CHWRMPowerImpl::DoStopChargingNotificationL(CHWRMPower::TBatteryChargingNotifier aNotifier)

	{	

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStopChargingNotificationL()" ));

	if (((aNotifier == CHWRMPower::EChargingNotifierAll)||(aNotifier == CHWRMPower::EChargingNotifierChargingCurrent))

        &&(iBatteryChargeCurrentRateAO))

		{

		COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close - canceling current measurement notifications" ));

		iBatteryChargeCurrentRateAO->Cancel();		

		User::LeaveIfError(iClient.ExecuteOperation(EHWRMStopAverageChargingCurrentReporting, TIpcArgs()));

		}

    if (((aNotifier == CHWRMPower::EChargingNotifierAll)||(aNotifier == CHWRMPower::EChargingNotifierBatteryFullChargingTime))

            &&(iBatteryChargingTimeAO))

            {

            COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::Close - canceling rem charging time measurement notifications" ));

            iBatteryChargingTimeAO->Cancel();      

            User::LeaveIfError(iClient.ExecuteOperation(EHWRMStopBatteryFullChargingTimeReporting, TIpcArgs()));

            }

	COMPONENT_TRACE1(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::DoStopChargingNotificationL - return" ));

	}