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

#include "HWRMPluginHandler.h"

#include "HWRMReservationHandler.h"

#include "HWRMtrace.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

_LIT( KPanicCategory, "HWRMLightService" );

const TUint KHWRMDefaultColor = 0;

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

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

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

// CHWRMLightService::CHWRMLightService

// C++ constructor

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

//

CHWRMLightService::CHWRMLightService(CHWRMLightCommonData& aLightCommonData)

    : iLightCommonData(aLightCommonData)

    {

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

    // Null the target timers to ensure proper cleanup if ConstructL leaves

    for( TInt i = 0; i < KHWRMLightMaxTargets; i++ )

        {

        iTargets[i].iTimer = NULL;

        }

    iSupportedTargets = iLightCommonData.SupportedTargets();

    iFullSystemTarget = iLightCommonData.FullSystemTarget();

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

    }

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

// CHWRMLightService::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMLightService::ConstructL(CHWRMPluginHandler* aPluginHandler,

                                   CHWRMReservationHandler* aReservationHandler)

    {

    COMPONENT_TRACE3(_L( "HWRM Server - CHWRMLightService::ConstructL(0x%x, 0x%x)" ), aPluginHandler, aReservationHandler);

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

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

    BaseConstructL(aPluginHandler, aReservationHandler);

    // initialize target timers (and the rest of the data, just in case)    

    TInt currentTarget(KHWRMLightFirstTarget);

    for( TInt i = 0; i < KHWRMLightMaxTargets; i++ )

        {

        // only initialize supported target timers

        if ( currentTarget & iSupportedTargets )

            {

            iTargets[i].iTimer = CHWRMGenericTimer::NewL(*this, KHWRMGenericTimerMaxTime, i);	

            }

        iTargets[i].iTarget = currentTarget;

        iTargets[i].iSuspended = EFalse;	

        iTargets[i].iReserved = EFalse;

        iTargets[i].iBaseState.iIntensity = KHWRMDefaultIntensity;	

        iTargets[i].iBaseState.iState = CHWRMLight::ELightStatusUnknown;

        iTargets[i].iBaseState.iFade = EFalse;

        iTargets[i].iBaseState.iOffCycleDuration = KHWRMDefaultCycleTime;

        iTargets[i].iBaseState.iOnCycleDuration = KHWRMDefaultCycleTime;

        iTargets[i].iBaseState.iColor = KHWRMInvalidColorMask;

        iTargets[i].iLastState.iIntensity = KHWRMDefaultIntensity;	

        iTargets[i].iLastState.iState = CHWRMLight::ELightStatusUnknown;

        iTargets[i].iLastState.iFade = EFalse;

        iTargets[i].iLastState.iOffCycleDuration = KHWRMDefaultCycleTime;

        iTargets[i].iLastState.iOnCycleDuration = KHWRMDefaultCycleTime;

        iTargets[i].iLastState.iColor = KHWRMInvalidColorMask;

        iTargets[i].iFrozenState.iIntensity = KHWRMDefaultIntensity;	

        iTargets[i].iFrozenState.iState = CHWRMLight::ELightStatusUnknown;

        iTargets[i].iFrozenState.iFade = EFalse;

        iTargets[i].iFrozenState.iOffCycleDuration = KHWRMDefaultCycleTime;

        iTargets[i].iFrozenState.iOnCycleDuration = KHWRMDefaultCycleTime;

        iTargets[i].iFrozenState.iColor = KHWRMInvalidColorMask;

        // move to next target

        currentTarget <<= 1;

        }

    iDefaultState.iIntensity = KHWRMDefaultIntensity;	

    iDefaultState.iState = CHWRMLight::ELightStatusUnknown; // This is updated based on inactivity time

    iDefaultState.iFade = ETrue;

    iDefaultState.iOffCycleDuration = KHWRMDefaultCycleTime;

    iDefaultState.iOnCycleDuration = KHWRMDefaultCycleTime;

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

    }

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

// CHWRMLightService::NewL

// Two-phased constructor.

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

//

CHWRMLightService* CHWRMLightService::NewL(CHWRMPluginHandler* aPluginHandler,

                                           CHWRMReservationHandler* aReservationHandler,

                                           CHWRMLightCommonData& aLightCommonData)

    {

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

    CHWRMLightService* self = new( ELeave ) CHWRMLightService(aLightCommonData);

    CleanupStack::PushL( self );

    self->ConstructL(aPluginHandler, aReservationHandler);

    CleanupStack::Pop();

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

    return self;

    }

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

// Destructor

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

//

CHWRMLightService::~CHWRMLightService()

    {

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

    CleanupLights();

    // Delete timers

    for( TInt i = 0; i < KHWRMLightMaxTargets; i++ )

        {

        delete iTargets[i].iTimer;

        }

    // Base class cleanup

    BaseDestruct();

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

    }

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

// CHWRMLightService::CleanupLights()

// Handles Light service cleanup

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

//

void CHWRMLightService::CleanupLights()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::CleanupLights()" ) );

    if (!iCleaningUp)

        {

        iCleaningUp = ETrue;

        TInt unreserved(0x0);

        TInt mask(0x0); // mask of targets

        // If any targets are still reserved, release them

        for( TInt i = 0; i < KHWRMLightMaxTargets; i++ )

            {

            if ( iTargets[i].iReserved )

                {

                COMPONENT_TRACE2(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMCleanupLights - Target index %d needs release." ), i );

                mask |= iTargets[i].iTarget;

                // Clear reserved and suspended flags

                iTargets[i].iReserved = EFalse;

                iTargets[i].iSuspended = EFalse;

                }

            }

        if ( mask )

            {

            unreserved = iReservationHandler->Release(this, mask);	

            }

        else

            {

            unreserved = iReservationHandler->GetUnreservedTargets();

            }

        mask = 0x0; // reset mask

        // Restore unreserved targets that have been affected by this session to default state.

        // Also cancel all timers.

        for( TInt i = 0; i < KHWRMLightMaxTargets; i++ )

            {

            if ( iTargets[i].iTimer && iTargets[i].iTimer->IsActive() )

                {

                iTargets[i].iTimer->Cancel();

                }

            if ( (unreserved & iTargets[i].iTarget) == iTargets[i].iTarget 

                 && iTargets[i].iLastState.iState != CHWRMLight::ELightStatusUnknown )

                {

                mask |= iTargets[i].iTarget;

                }

            }

        // Restore default states if needed. iTargets[0] is used as dummy.

        // The aMessage pointer is required for completion after transaction.

        if ( mask )

            {

            // Cannot restore both system targets and non-system targets with same command, so do them separately.

            TInt subMask(mask & iFullSystemTarget);

            if ( subMask )

                {

                RestoreState(iTargets[0], EStateChangeDefaultState, EFalse, subMask);

                }

            subMask = mask & ~subMask; // rest of targets

            if ( subMask )

                {

                RestoreState(iTargets[0], EStateChangeDefaultState, EFalse, subMask);

                }

            }

        }

    else

        {

        COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::CleanupLights - Already cleaned up" ) );

        }

    COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::CleanupLights - return" ) );        

    }

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

// CHWRMLightService::ExecuteMessageL

// Handles Light requests. 

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

//

TBool CHWRMLightService::ExecuteMessageL( const RMessage2& aMessage )

    {

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

    // If cleaning up or dummy message, something has gone wrong, so leave.

    if ( aMessage.IsNull() || iCleaningUp )

        {

        User::Leave(KErrBadHandle);

        }

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

    TBool completeMessage(EFalse);

    switch ( aMessage.Function() )

        {

    	case EHWRMLightsOn:

    	    {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMLightsOn" ) );

            THWRMLightsOnCmdPackage pckg;

            aMessage.ReadL( 0, pckg );

            THWRMLightsOnData* commandData = &(pckg());

    	    LightsOnL( commandData->iTarget, 

    	               commandData->iDuration, 

    	               commandData->iIntensity, 

    	               commandData->iFadeIn, 

    	               aMessage );

    		break;

    	    }

    	case EHWRMLightsOff:

    	    {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMLightsOff" ) );

            THWRMLightsOffCmdPackage pckg;

            aMessage.ReadL( 0, pckg );

            THWRMLightsOffData* commandData = &(pckg());

    	    LightsOffL( commandData->iTarget,

    	                commandData->iDuration, 

    	                commandData->iFadeOut, 

    	                aMessage );

    		break;

    	    }

    	case EHWRMLightsBlink:

    	    {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMLightsBlink" ) );

            THWRMLightsBlinkCmdPackage pckg;

            aMessage.ReadL( 0, pckg );

            THWRMLightsBlinkData* commandData = &(pckg());

    	    LightsBlinkL( commandData->iTarget,

    	                  commandData->iDuration, 

    	                  commandData->iIntensity, 

    	                  commandData->iOnCycleDuration, 

    	                  commandData->iOffCycleDuration, 

    	                  aMessage );

    		break;

    	    }

    	case EHWRMReserveLights:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMReserveLights") );

            ReserveLightsL(aMessage);

            completeMessage = ETrue; // Since using dummy messages for freeze state restores, need complete always.

    		break;

    	    }

    	case EHWRMReleaseLights:

    	    {

            COMPONENT_TRACE1(_L("HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMReleaseLights") );

            // Release specified targets

            TInt targetMask(aMessage.Int0());

            ReleaseLights(targetMask);

            completeMessage = ETrue; // Since using dummy messages for default state restores, need complete always.

    		break;

    	    }

        case EHWRMGetSupportedTargets:

            {

	        // Get the supported targets and return them in parameter 0

            TPtrC8 value( reinterpret_cast<TUint8*>(&iSupportedTargets), sizeof( iSupportedTargets ) );

            aMessage.WriteL( 0, value );

            completeMessage = ETrue;

            break;

            }

    	case EHWRMCleanupLights:

    	    {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMCleanupLights" ) );

            CleanupLights();

            // Complete, as dummy messages are used in cleanup

            completeMessage = ETrue;

    		break;

    	    }

        case EHWRMSetLightColor:

            {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMSetLightColor" ) );

            THWRMSetColorCmdPackage pckg;

            aMessage.ReadL( 0, pckg );

            THWRMSetColorData* commandData = &(pckg());

    	    SetColorL( commandData->iTarget, 

    	               commandData->iColor, 

    	               aMessage );

    		break;

    	    }

        case EHWRMLightsOnWithColor:

            {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMLightsOnWithColor" ) );

            THWRMLightsOnCmdPackage pckg;

            aMessage.ReadL( 0, pckg );

            THWRMLightsOnData* commandData = &(pckg());

            //Data allocated here will be freed in SetColorL if target is suspended

            //else will be freed in CompleteRequest for SetColorL

            THWRMLightsOnData* lightOnData = new(ELeave) THWRMLightsOnData;

            lightOnData->iTarget    = commandData->iTarget;

            lightOnData->iFadeIn    = commandData->iFadeIn;

            lightOnData->iDuration  = commandData->iDuration;

            lightOnData->iIntensity = commandData->iIntensity;

            CleanupStack::PushL( lightOnData );

            // coverity[freed_arg]

            TBool pluginCommandCalled = SetColorL(commandData->iTarget, commandData->iColor, aMessage, 

                                                  EFalse, ETrue, HWRMLightCommand::ELightsOnCmdId, lightOnData);

            //SetColor will store the pointer(lightOnData) as splitcommand data.

            //This will freed after ProcessResponseL.

            CleanupStack::Pop( lightOnData );

            if(!pluginCommandCalled)

                {

                //Target is suspended, so call light on.

                //Message is completed to client and last state is stored.

                LightsOnL( commandData->iTarget, 

                                      commandData->iDuration, 

                                      commandData->iIntensity, 

                                      commandData->iFadeIn, 

                                      aMessage );

                }

            break;

            }

        case EHWRMLightsBlinkWithColor:

            {

            COMPONENT_TRACE1(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - EHWRMLightsBlinkWithColor" ) );

            THWRMLightsBlinkCmdPackage pckg;

            aMessage.ReadL( 0, pckg );

            THWRMLightsBlinkData* commandData = &(pckg());

            //Data allocated here will be freed in SetColorL if target is suspended

            //else will be freed in CompleteRequest for SetColorL

            THWRMLightsBlinkData* lightBlinkData = new(ELeave) THWRMLightsBlinkData;

            lightBlinkData->iTarget           = commandData->iTarget;

            lightBlinkData->iDuration         = commandData->iDuration; 

            lightBlinkData->iIntensity        = commandData->iIntensity; 

            lightBlinkData->iOnCycleDuration  = commandData->iOnCycleDuration; 

            lightBlinkData->iOffCycleDuration = commandData->iOffCycleDuration;

            CleanupStack::PushL( lightBlinkData );

            // coverity[freed_arg]

            TBool pluginCommandCalled = SetColorL(commandData->iTarget, commandData->iColor, aMessage, 

                                                  EFalse, ETrue, HWRMLightCommand::ELightsBlinkCmdId, lightBlinkData);

            //SetColor will store the pointer(lightBlinkData) as splitcommand data.

            //This will freed after ProcessResponseL.

            CleanupStack::Pop( lightBlinkData );

            if(!pluginCommandCalled)

                {

                //Target is suspended, so call light Blink.

                //Message is completed to client and last state is stored.

                LightsBlinkL( commandData->iTarget,

                              commandData->iDuration, 

                              commandData->iIntensity, 

                              commandData->iOnCycleDuration, 

                              commandData->iOffCycleDuration, 

                              aMessage );

                }

            break;

            }

        // Cannot identify the message, panic the client

        default:

            {

            CHWRMServer::PanicClient(aMessage, EPanicIllegalFunction);

            break;

            }

        }

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMLightService::ExecuteMessageL - return 0x%x" ), completeMessage );

    return completeMessage;

    }

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

// CHWRMLightService::ReleaseLights

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

//

void CHWRMLightService::ReleaseLights(TInt aTargetMask)

    {

    COMPONENT_TRACE2(_L( "HWRM Server - CHWRMLightService::ReleaseLights(0x%x)" ), aTargetMask );

    TInt targetMask = aTargetMask;

    // Change mask if releasing system target 

    if ( targetMask & CHWRMLight::ESystemTarget )

        {

        targetMask = iFullSystemTarget;

        }

    else

        {

        // Strip unsupported targets from mask since those cannot be reserved anyway.

        targetMask &= iSupportedTargets;