// 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" ));
	}

void CHWRMPowerImpl::ChargingStatusChange(TInt aErrCode,CHWRMPower::TBatteryChargingStatus aChrgStatus)
    {
    if(iChargingStatusClientObserver)
        {
        iChargingStatusClientObserver->ChargingStatusChange(aErrCode, aChrgStatus);
        }

    //Test if notification is already stopped.
    //If already stopped, no need to cancel notification.
    TBool batteryChargeCurrentNotificationOn(EFalse);
    TBool batteryChargingTimeNotificationOn(EFalse);
    if(iBatteryChargeCurrentRateAO)
        {
        batteryChargeCurrentNotificationOn = iBatteryChargeCurrentRateAO->IsActive();
        }
    if(iBatteryChargingTimeAO)
        {
        batteryChargingTimeNotificationOn = iBatteryChargingTimeAO->IsActive();
        }
    COMPONENT_TRACE3(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::ChargingStatusChange batteryChargeCurrentNotificationOn=%d batteryChargingTimeNotificationOn=%d" ), batteryChargeCurrentNotificationOn, batteryChargingTimeNotificationOn );
    
    if(batteryChargeCurrentNotificationOn || batteryChargingTimeNotificationOn)
        {
        //Avoid using multiple TRAP's in "if and else" part below.
        //Just store whether notification(and corresponding code) needs to stopped or not.
        TBool                                stopchargingNotification(ETrue);
        CHWRMPower::TBatteryChargingNotifier cancelNotificationCode;
        
        //Stop charging notifications, if charger is not connected.
        if((aErrCode != KErrNone) || 
           (aChrgStatus == CHWRMPower::EChargingStatusError) || 
           (aChrgStatus == CHWRMPower::EChargingStatusNotConnected) || 
           (aChrgStatus == CHWRMPower::EChargingStatusNotCharging))
            {
            cancelNotificationCode       = CHWRMPower::EChargingNotifierAll;
            }
        //Stop remaining charging time notification, if charging is completed.
        else if(aChrgStatus == CHWRMPower::EChargingStatusChargingComplete)
            {
            cancelNotificationCode   = CHWRMPower::EChargingNotifierBatteryFullChargingTime;
            }
        else
            {
            stopchargingNotification = EFalse;
            }

        COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::ChargingStatusChange stopchargingNotification 0x%x" ), stopchargingNotification );
    
        if(stopchargingNotification)
            {
            
            TInt err;
            TRAP(err, DoStopChargingNotificationL(cancelNotificationCode));
    
            if(err == KErrNone)
                {
                //Since the measurements are stopped by HWRM(because of some external events),
                //HWRM clients Notifications needs to be cancelled.
            
                //Charging time notification is cancelled in both cases(EChargingNotifierAll and EChargingNotifierBatteryFullChargingTime)
                if(batteryChargingTimeNotificationOn)
                    {
                    iBatteryChargingTimeAO->CancelClientNotification();
                    }
            
                if(cancelNotificationCode == CHWRMPower::EChargingNotifierAll) 
                    {
                    if(batteryChargeCurrentNotificationOn)
                        {
                        iBatteryChargeCurrentRateAO->CancelClientNotification();
                        }
                    }
                }
            else
                {
                //Just trace the error,as nothing can be done.
                COMPONENT_TRACE2(_L( "HWRM CHWRMPowerImpl - CHWRMPowerImpl::ChargingStatusChange stop failed with 0x%x" ), err );
                }
            }
        }
    }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

