// 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 "HWRMServer.h"

#include "HWRMService.h"

#include "HWRMPowerService.h"

#include "HWRMPluginHandler.h"

#include "HWRMPowerCommands.h"

#include "HWRMPowerClientServer.h"

#include "HWRMPower.h"

#include "HWRMtrace.h"

// CONSTANTS

_LIT( KPanicCategory, "HWRMPowerService" );

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

//All the measurements from the plugin are sent to client.

const TUint KRemainingChargingTimeInterval(1);

#endif

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

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

// CHWRMPowerService::CHWRMPowerService

// C++ constructor

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

//

CHWRMPowerService::CHWRMPowerService(CHWRMPowerCommonData& aPowerCommonData)

    : iPowerCommonData(aPowerCommonData)

    {

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

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

    }

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

// CHWRMPowerService::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMPowerService::ConstructL(CHWRMPluginHandler* aPluginHandler)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMPowerService::ConstructL(0x%x)" ), aPluginHandler);

    __ASSERT_ALWAYS(aPluginHandler, User::Panic(KPanicCategory, EPanicBadHandle));

    BaseConstructL(aPluginHandler, NULL);

    iPowerVoltageCurrentMeasurementsClientData = new(ELeave) TPowerVoltageCurrentMeasurementsClientData();

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

    iPowerChargingCurrentMeasurementsClientData = new(ELeave) TPowerIntMeasurementsClientData();

    iPowerChargingTimeMeasurementsClientData = new(ELeave)TPowerIntMeasurementsClientData();

    iPowerChargingTimeMeasurementsClientData->iRequestedIntervalMultiple = KRemainingChargingTimeInterval;

#endif //SYMBIAN_HWRM_EXTPOWERINFO

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

    }

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

// CHWRMPowerService::NewL

// Two-phased constructor.

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

//

CHWRMPowerService* CHWRMPowerService::NewL(CHWRMPluginHandler* aPluginHandler, CHWRMPowerCommonData& aPowerCommonData)

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMPowerService::NewL(0x%x)" ), aPluginHandler);

    CHWRMPowerService* self = new( ELeave ) CHWRMPowerService(aPowerCommonData);

    CleanupStack::PushL( self );

    self->ConstructL(aPluginHandler);

    CleanupStack::Pop( self );

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

    return self;

    }

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

// Destructor

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

//

CHWRMPowerService::~CHWRMPowerService()

    {

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

   	iPowerCommonData.CancelPendingGetBatteryInfo(*this);

   	iPowerCommonData.CancelPendingGetBatteryVoltageInfo(*this);

    if (iPowerVoltageCurrentMeasurementsClientData)

      	{

       iPowerVoltageCurrentMeasurementsClientData->CancelPendingGetMeasurementsMessage();           

       iPowerCommonData.iPowerReportClientsData->RemoveMeasurementsClientData(iPowerVoltageCurrentMeasurementsClientData);

       delete iPowerVoltageCurrentMeasurementsClientData;

       iPowerVoltageCurrentMeasurementsClientData = NULL;

       if (iPowerCommonData.iPowerReportClientsData->IsClientsQueEmpty() &&

       	iPowerCommonData.iPowerReportClientsData->IsMeasuringOn())

       	{

       	TRAPD(err, iPowerCommonData.DoStopPowerMeasurementsL());

			if (err != KErrNone)

				{

				// Cannot do anything here. Just trace it

				COMPONENT_TRACE2( _L( "HWRM Server - CHWRMPowerService::~CHWRMPowerService() - Stopping power(currentAndvoltage) measurement failed: %d" ), err);

				}

       	}

   	}

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

     if (iPowerChargingCurrentMeasurementsClientData)

       	{

        iPowerChargingCurrentMeasurementsClientData->CancelPendingGetMeasurementsMessage();           

        iPowerCommonData.iChargingCurrentClientsData->RemoveMeasurementsClientData(iPowerChargingCurrentMeasurementsClientData);

        delete iPowerChargingCurrentMeasurementsClientData;

        iPowerChargingCurrentMeasurementsClientData = NULL;

        if (iPowerCommonData.iChargingCurrentClientsData->IsClientsQueEmpty() &&

        	iPowerCommonData.iChargingCurrentClientsData->IsMeasuringOn())

        	{

        	TRAPD(err, iPowerCommonData.DoStopChargingCurrentMeasurementsL());

			if (err != KErrNone)

				{

				// Cannot do anything here. Just trace it

				COMPONENT_TRACE2( _L( "HWRM Server - CHWRMPowerService::~CHWRMPowerService() - Stopping charging current measurement failed: %d" ), err);

				}

        	}

    	}

     if (iPowerChargingTimeMeasurementsClientData)

         {

         iPowerChargingTimeMeasurementsClientData->CancelPendingGetMeasurementsMessage();           

         iPowerCommonData.iChargingTimeClientsData->RemoveMeasurementsClientData(iPowerChargingTimeMeasurementsClientData);

         delete iPowerChargingTimeMeasurementsClientData;

         iPowerChargingTimeMeasurementsClientData = NULL;

         if (iPowerCommonData.iChargingTimeClientsData->IsClientsQueEmpty() &&

             iPowerCommonData.iChargingTimeClientsData->IsMeasuringOn())

             {

             TRAPD(err, iPowerCommonData.DoStopChargingTimeMeasurementsL());

             if (err != KErrNone)

                 {

                 // Cannot do anything here. Just trace it

                 COMPONENT_TRACE2( _L( "HWRM Server - CHWRMPowerService::~CHWRMPowerService() - Stopping charging time measurement failed: %d" ), err);

                 }

             }

         }

 #endif //SYMBIAN_HWRM_EXTPOWERINFO

    // Base class cleanup

    BaseDestruct();

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

    }

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

// CHWRMPowerService::ExecuteMessageL

// Handles Power requests.  Called from the client session via CSession2::ServiceL

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

//

TBool CHWRMPowerService::ExecuteMessageL( const RMessage2& aMessage )

    {

    COMPONENT_TRACE2( _L( "HWRM Server - CHWRMPowerService::ExecuteMessageL(0x%x)" ), aMessage.Function());

    if ( aMessage.IsNull() )

        {

        User::Leave(KErrBadHandle);

        }

    // All messages are by default asynchronous because of the nature of the plugin API

    TBool completeMessage(EFalse);

    switch ( aMessage.Function() )

        {

        case EHWRMCleanupBattery:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMCleanupBattery") );  

            CleanupPowerL();

            completeMessage = ETrue;

            break;

            }

        case EHWRMGetBatteryInfo:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMGetBatteryInfo") );

            // The plugin command will be issued by the service belonging to the PowerCommonData. The PowerCommonData

            // keep a list of all the pending requests. A plugin command is issued only for the first request. If a client

            // requests the same data and finds that there is a pending plugin request it won't issue a new one.

            // Will be completed all together when the plugin responds to the service.

            iPowerCommonData.DoGetBatteryInfoL(aMessage, *this);

            break;

            }

        case EHWRMGetBatteryVoltageInfo:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMGetBatteryVoltageInfo") );

            // The plugin command will be issued by the service belonging to the PowerCommonData. The PowerCommonData

            // keep a list of all the pending requests. A plugin command is issued only for the first request. If a client

            // requests the same data and finds that there is a pending plugin request it won't issue a new one.

            // Will be completed all together when the plugin responds to the service.

            iPowerCommonData.DoGetBatteryVoltageInfoL(aMessage, *this);

            break;

            }

        case EHWRMStartAverageBatteryPowerReporting:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMStartAverageBatteryPowerReporting") );

            if (iPowerVoltageCurrentMeasurementsClientData->IsMeasuringOn() || 

            	iPowerVoltageCurrentMeasurementsClientData->iRequestedStartMessage.Handle())

            	{

            	User::Leave(KErrAlreadyExists);

            	}

     		TPckgBuf<TUint> intervalMultiplePckg;

         	aMessage.ReadL(0,intervalMultiplePckg);         	

        	iPowerVoltageCurrentMeasurementsClientData->iRequestedIntervalMultiple = intervalMultiplePckg();

            if (iPowerCommonData.iPowerReportClientsData->IsMeasuringOn())

            	{

            	COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMStartAverageBatteryPowerReporting: Power Reporting is already On") );                          

            	// plugin is already ON.

            	// Just add it to the list and (if needed) update the plugin Interval Multiple

            	if (iPowerCommonData.iPowerReportClientsData->NeedPluginIntervalAdjustment(iPowerVoltageCurrentMeasurementsClientData->iRequestedIntervalMultiple))

            		{            		

            		TUint currentPluginIntervalMultiple;

            	 	iPowerCommonData.iPowerReportClientsData->GetPluginIntervalMultiple(currentPluginIntervalMultiple);

            	 	TUint currentGCD = currentPluginIntervalMultiple;

            	 	TUint newPluginIntervalMultiple;

            	 	TUint clientsInterval = intervalMultiplePckg();

            	 	TUint newGCD = iPowerCommonData.iPowerReportClientsData->CalculateGCD(currentGCD, clientsInterval);	

            	 	newPluginIntervalMultiple = newGCD;

            	 	// save the message so that the message is completed when the plugin responds

                	iPowerVoltageCurrentMeasurementsClientData->iRequestedStartMessage = aMessage;

            	 	SetPluginIntervalMultipleL(HWRMPowerCommand::ESetPowerReportingIntervalMultipleCmdId, newPluginIntervalMultiple);

            		}

            	else

            		{

            		iPowerCommonData.iPowerReportClientsData->AddMeasurementsClientL(*iPowerVoltageCurrentMeasurementsClientData);

            		iPowerVoltageCurrentMeasurementsClientData->SetMeasuringOn();

                	completeMessage = ETrue; // won't issue a plugin request. Accesses the common data

            		}

            	}

            else

            	{

            	// send command to the plugin to start Average Battery measurements

            	// if successful client will be added on the plugin response

            	iPowerVoltageCurrentMeasurementsClientData->iRequestedStartMessage = aMessage;

            	StartAverageBatteryPowerReportingL(aMessage);

            	}

            break;

            }

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

        case EHWRMStartAverageChargingCurrentReporting:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMStartAverageChargingCurrentReporting") );

            if (iPowerChargingCurrentMeasurementsClientData->IsMeasuringOn() || 

            	iPowerChargingCurrentMeasurementsClientData->iRequestedStartMessage.Handle())

            	{

            	User::Leave(KErrAlreadyExists);

            	}

     		TPckgBuf<TUint> intervalPckg;

         	aMessage.ReadL(0,intervalPckg);         	

        	iPowerChargingCurrentMeasurementsClientData->iRequestedIntervalMultiple = intervalPckg();

            if (iPowerCommonData.iChargingCurrentClientsData->IsMeasuringOn())

            	{

            	COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMStartAverageChargingCurrentReporting:  is already On") );                          

            	// plugin is already ON.

            	// Just add it to the list and (if needed) update the plugin Interval Multiple

            	if (iPowerCommonData.iChargingCurrentClientsData->NeedPluginIntervalAdjustment(iPowerChargingCurrentMeasurementsClientData->iRequestedIntervalMultiple))

            		{            		

            		TUint currentPluginIntervalMultiple;

            	 	iPowerCommonData.iChargingCurrentClientsData->GetPluginIntervalMultiple(currentPluginIntervalMultiple);

            	 	TUint currentGCD = currentPluginIntervalMultiple;

            	 	TUint newPluginIntervalMultiple;

            	 	TUint clientsInterval = intervalPckg();

            	 	TUint newGCD = iPowerCommonData.iChargingCurrentClientsData->CalculateGCD(currentGCD, clientsInterval);	

            	 	newPluginIntervalMultiple = newGCD;

            	 	// save the message so that the message is completed when the plugin responds

                	iPowerChargingCurrentMeasurementsClientData->iRequestedStartMessage = aMessage;

            	 	SetPluginIntervalMultipleL(HWRMPowerCommand::ESetChargeCurrentIntervalMultipleCmdId, newPluginIntervalMultiple);

            		}

            	else

            		{

            		iPowerCommonData.iChargingCurrentClientsData->AddMeasurementsClientL(*iPowerChargingCurrentMeasurementsClientData);

            		iPowerChargingCurrentMeasurementsClientData->SetMeasuringOn();

                	completeMessage = ETrue; // won't issue a plugin request. Accesses the common data

            		}

            	}

            else

            	{

            	// send command to the plugin to start Average Battery measurements

            	// if successful client will be added on the plugin response

            	iPowerChargingCurrentMeasurementsClientData->iRequestedStartMessage = aMessage;

            	StartAverageChargingCurrentReportingL(aMessage);

            	}

            break;

            }

        case EHWRMStartBatteryFullChargingTimeReporting:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMStartBatteryFullChargingTimeReporting") );

            if (iPowerChargingTimeMeasurementsClientData->IsMeasuringOn() || 

            	iPowerChargingTimeMeasurementsClientData->iRequestedStartMessage.Handle())

            	{

            	User::Leave(KErrAlreadyExists);

            	}

            //Set to 1, as all measurements are sent to client.

            //The time interval is determined by plugin.

        	iPowerChargingTimeMeasurementsClientData->iRequestedIntervalMultiple = 1;

            if (iPowerCommonData.iChargingTimeClientsData->IsMeasuringOn())

            	{

            	COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMStartBatteryFullChargingTimeReporting: Charging Time Reporting is already On") );                          

            	// plugin is already ON.

            	// Just add it to the list as no plugin interval update is required.

        		iPowerCommonData.iChargingTimeClientsData->AddMeasurementsClientL(*iPowerChargingTimeMeasurementsClientData);

        		iPowerChargingTimeMeasurementsClientData->SetMeasuringOn();

            	completeMessage = ETrue; // won't issue a plugin request. Accesses the common data

            	}

            else

            	{

            	// send command to the plugin to start Battery Full Charging Time reporting

            	// if successful client will be added on the plugin response

            	iPowerChargingTimeMeasurementsClientData->iRequestedStartMessage = aMessage;

            	StartChargingTimeReportingL(aMessage);

            	}

            break;

            }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

        case EHWRMGetPowerMeasurements:

                    {

                    COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMGetPowerMeasurements") );

                    if (iPowerVoltageCurrentMeasurementsClientData->iRequestedBatchMessage.Handle())

                        {

                        // Not allowed to have more than one pending getBatch messages. 

                        User::Leave(KErrServerBusy);

                        }

                    if (iPowerVoltageCurrentMeasurementsClientData->IsMeasuringOn())

                        {                    

                        // if there is a measurement ready the message is completed.

                        // if not the commondata will complete the message when ready 

                        completeMessage = iPowerVoltageCurrentMeasurementsClientData->GetMeasurementsL( aMessage );

                        }

                    else if (iPowerVoltageCurrentMeasurementsClientData->iRequestedStartMessage.Handle())

                        {

                        // else waiting for plugin to start measurements. Don't complete message just save it.

                        iPowerVoltageCurrentMeasurementsClientData->iRequestedBatchMessage = aMessage;             

                        }

                    else 

                        {

                        // Measurements have been stoped by client or because Max Reporting period was reached

                        // Need to issue a start before retrieving measurements

                        User::Leave(KErrNotReady);

                        }       

                    break;      

                    }

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

        case EHWRMGetAverageChargingCurrentMeasurements:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMGetAverageChargingCurrentMeasurements") );

            if (iPowerChargingCurrentMeasurementsClientData->iRequestedBatchMessage.Handle())

            	{

            	// Not allowed to have more than one pending getBatch messages. 

            	User::Leave(KErrServerBusy);

            	}

        	if (iPowerChargingCurrentMeasurementsClientData->IsMeasuringOn())

        		{                    

                // if there is a measurement ready the message is completed.

                // if not the commondata will complete the message when ready 

                completeMessage = iPowerChargingCurrentMeasurementsClientData->GetMeasurementsL( aMessage );

        		}

        	else if (iPowerChargingCurrentMeasurementsClientData->iRequestedStartMessage.Handle())

        		{

            	// else waiting for plugin to start measurements. Don't complete message just save it.

        		iPowerChargingCurrentMeasurementsClientData->iRequestedBatchMessage = aMessage;     		

        		}

            else 

            	{

                // Measurements have been stoped by client or because Max Reporting period was reached

                // Need to issue a start before retrieving measurements

            	User::Leave(KErrNotReady);

            	}       

            break;      

            }

        case EHWRMGetBatteryFullChargingTimeMeasurements:

            {

            COMPONENT_TRACE1( _L("HWRM Server - CHWRMPowerService::ExecuteMessageL - EHWRMGetBatteryFullChargingTimeMeasurements") );

            if (iPowerChargingTimeMeasurementsClientData->iRequestedBatchMessage.Handle())

            	{

            	// Not allowed to have more than one pending getBatch messages. 

            	User::Leave(KErrServerBusy);

            	}

        	if (iPowerChargingTimeMeasurementsClientData->IsMeasuringOn())

        		{                    

                // if there is a measurement ready the message is completed.

                // if not the commondata will complete the message when ready 

                completeMessage = iPowerChargingTimeMeasurementsClientData->GetMeasurementsL( aMessage );

        		}

        	else if (iPowerChargingTimeMeasurementsClientData->iRequestedStartMessage.Handle())

        		{

            	// else waiting for plugin to start measurements. Don't complete message just save it.

        		iPowerChargingTimeMeasurementsClientData->iRequestedBatchMessage = aMessage;     		

        		}

            else 

            	{

                // Measurements have been stoped by client or because Max Reporting period was reached

                // Need to issue a start before retrieving measurements

            	User::Leave(KErrNotReady);

            	}       

            break;      

            }

#endif //SYMBIAN_HWRM_EXTPOWERINFO

        case EHWRMStopAverageBatteryPowerReporting:

            {

            if (iPowerVoltageCurrentMeasurementsClientData->IsMeasuringOn() ||

                iPowerVoltageCurrentMeasurementsClientData->iRequestedStartMessage.Handle())

            	{    

            	// will leave if client is not found in the list. Hence, no client that has not issued

            	// a start can call stop for a measurements session

            	iPowerCommonData.iPowerReportClientsData->RemoveMeasurementsClientL(iPowerVoltageCurrentMeasurementsClientData);          

            	iPowerVoltageCurrentMeasurementsClientData->CompleteGetMeasurementsMessage(KErrNone);

            	iPowerVoltageCurrentMeasurementsClientData->CompletePendingStart(KErrNone);

            	//if there are no registered clients stop the plugin measurements            	

            	if(iPowerCommonData.iPowerReportClientsData->IsClientsQueEmpty())

            		{

            		// send command to the plugin to stop Average Battery power measurements            		

            		 iPowerCommonData.DoStopPowerMeasurementsL();	

            		}

            	else

            		{

            		TUint newIntervalMultiple;

            		TUint currentIntervalMultiple;

            		iPowerCommonData.iPowerReportClientsData->RecalculatePluginInterval(newIntervalMultiple);

            		TUint newGCD = newIntervalMultiple;

            		iPowerCommonData.iPowerReportClientsData->GetPluginIntervalMultiple(currentIntervalMultiple);

            		TUint currentGCD = currentIntervalMultiple;

            		if( newGCD != currentGCD)

            			{			            		

            			iPowerCommonData.DoSetPluginIntervalMultipleL(HWRMPowerCommand::ESetPowerReportingIntervalMultipleCmdId, newIntervalMultiple);

            			}

            		}