// 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 <e32svr.h>

#include <centralrepository.h>

#include "HWRMExtendedLightImpl.h"

#include "HWRMLightClientServer.h"

#include "HWRMtrace.h"

#include "HWRMExtendedLightStatusObserver.h"

#include "HWRMPrivatePSKeys.h"

#include "hwrmuipluginhandler.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CHWRMExtendedLightImpl::CHWRMExtendedLightImpl

// C++ constructor

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

//

CHWRMExtendedLightImpl::CHWRMExtendedLightImpl()

    {

    COMPONENT_TRACE1(_L( "HWRM LightClient - CHWRMExtendedLightImpl::CHWRMExtendedLightImpl()" ) );

    COMPONENT_TRACE1(_L( "HWRM LightClient - CHWRMExtendedLightImpl::CHWRMExtendedLightImpl - return" ));

    }

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

// CHWRMExtendedLightImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHWRMExtendedLightImpl::ConstructL(MHWRMExtendedLightObserver* aCallback, TInt aPermittedTargets)

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ConstructL()" ) );

    // NULL is acceptable value for aCallback, just means that 

    // client is not interested in callbacks.

    iCallback = aCallback;

    // Connect the session and order notifications

    OpenL(aPermittedTargets);    

  	TInt err(KErrNone);    

   	TRAP(err, iUiPluginHandler = CHwrmUiPluginHandler::NewL( ));

   	if ( err == KErrNone )

    	{

    	COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ConstructL() - successfully instantiated UI plugin handler" ) );

    	iUiPluginHandler->AddForegroundObserverL(this);    	

    	}

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ConstructL - return" ) );    

    }

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

// Destructor

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

//

CHWRMExtendedLightImpl::~CHWRMExtendedLightImpl()

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::~CHWRMExtendedLightImpl()" ) );        

    // close HWRM client, also deletes status observers

    Close();

    // iCallback is not owned so it is not cleaned, just set to NULL 

    iCallback = NULL;

    // status observer is deleted in close. Set to NULL to avoid pc-lint warning

    iStatusObserver = NULL; 

    delete iUiPluginHandler; 

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::~CHWRMExtendedLightImpl - return" ) );

    }

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

// CHWRMExtendedLightImpl::OpenL

// Opens session and orders notifications

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

//

void CHWRMExtendedLightImpl::OpenL(TInt aSupportedTargets)

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Open()" ));

    // Returns either error or target mask

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

    TPtr8 ptr( reinterpret_cast<TUint8*>(&iSupportedTargets), sizeof(iSupportedTargets), sizeof(iSupportedTargets) );

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMGetSupportedTargets, TIpcArgs(&ptr)));

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Open - Supported targets: 0x%x" ), iSupportedTargets );

	// When the extended light client has been created from CHWRMLight, only the targets

	// available to SDK users are allowed. The rest of the targets must be filtered out.

	if (aSupportedTargets != -1) // default value (-1): all targets permitted

		{

		iSupportedTargets &= aSupportedTargets;

		}

    // Order status notifications

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Open - Ordering notifications" ) );

    iStatusObserver = CHWRMExtendedLightStatusObserver::NewL(iCallback, iSupportedTargets);

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Open - return" ) );

    }

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

// CHWRMExtendedLightImpl::Close

// Closes session.

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

//

void CHWRMExtendedLightImpl::Close()

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Close()" ));

    // Inform session that we are cleaning up now.

    // Ignore errors, just trace them

    if (iClient.Handle())

        {

        iClient.ExecuteOperation(EHWRMCleanupLights, TIpcArgs());

        }

    // Abort status notifications

    if ( iStatusObserver )

        {

        COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Close - canceling Light Status notifications" ) );

        iStatusObserver->Cancel();

        delete iStatusObserver;

        iStatusObserver = NULL;

        }	                

    iClient.Close();

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::Close - return" ) );

    }

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

// CHWRMExtendedLightImpl::ReserveLightL

// Reserve light targets

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

//

void CHWRMExtendedLightImpl::ReserveLightL(TInt aTarget)

    {

    ReserveLightL( aTarget, EFalse, EFalse );

    }

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

// CHWRMExtendedLightImpl::ReserveLightL

// Reserve light targets

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

//

void CHWRMExtendedLightImpl::ReserveLightL(TInt aTarget, 

                                           TBool aRestoreState, 

                                           TBool aForceNoCCoeEnv)

    {

    COMPONENT_TRACE4(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReserveLightL(0x%x, 0x%x, 0x%x)" ), aTarget, aRestoreState, aForceNoCCoeEnv);

    CheckTargetParameterL( aTarget );

    if ( !aForceNoCCoeEnv )

        {        

 		if(iUiPluginHandler)

    		{

    		// Check that we are on foreground (i.e. we have keyboard focus.)

            // Note: There can be windows on top of our application that have explicitly disabled keyboard focus,

            // but then again the foreground/background observer will not kick in in those cases either.

            // -> We can use focus to determine foreground status here.            

    		if(iUiPluginHandler->InForeground() == EFalse)

    			{

    			COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReserveLightL - Application does not have focus, Reserve denied." ) );

                User::Leave(KErrNotReady);                

    			}

    		} 		        	

        else

        	{

            COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReserveLightL - No  iUiPluginHandler available" ) );

            User::Leave(KErrBadHandle);        	

        	}

        }

    // Do the actual reservation

    DoReserveLightL(aTarget, aRestoreState, aForceNoCCoeEnv);

    if ( !aForceNoCCoeEnv )

        {

        // update autoreserve mask

        iAutoReserving |= aTarget;

        COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReserveLightL - Updated autoreserve mask: 0x%x" ), iAutoReserving );

        }

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReserveLightL - return" ) );

    }

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

// CHWRMExtendedLightImpl::ReleaseLight

// Release light targets

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

//

void CHWRMExtendedLightImpl::ReleaseLight(TInt aTarget)

    {

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReleaseLight(0x%x)" ), aTarget );

    DoReleaseLight(aTarget);

    iAutoReserving &= ~aTarget;

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReleaseLight - Updated autoreserve mask: 0x%x" ), iAutoReserving );

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::ReleaseLight - return" ) );

    }

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

// CHWRMExtendedLightImpl::DoReserveLightL

// Reserve vibra resource

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

//

void CHWRMExtendedLightImpl::DoReserveLightL(TInt aTarget, TBool aRestoreState, TBool aForceNoCCoeEnv)

    {

    COMPONENT_TRACE4(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::DoReserveLightL(0x%x, 0x%x, 0x%x)" ), aTarget, aRestoreState, aForceNoCCoeEnv);

    // Check if these targets are already reserved by this session. 

    // In that case do nothing.

    if ( (iReserved & aTarget) != aTarget  )

        {

        // Execute reservation

        User::LeaveIfError(iClient.ExecuteOperation(EHWRMReserveLights, TIpcArgs(aTarget, aRestoreState, aForceNoCCoeEnv)));

        // Reserve successful, mark as reserved.

        iReserved |= aTarget;

        }

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::DoReserveLightL - return" ) );

    }

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

// CHWRMExtendedLightImpl::DoReleaseLight

// Release vibra resource

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

//

void CHWRMExtendedLightImpl::DoReleaseLight(TInt aTarget)

    {

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::DoReleaseLight(0x%x)" ), aTarget );

    // Only release if any of specified targets reserved.

    if ( iReserved & aTarget )

        {

        // Execute release

        TInt err = iClient.ExecuteOperation(EHWRMReleaseLights, TIpcArgs(aTarget));

        if ( err != KErrNone )

            {

            COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::DoReleaseLight - Release execution failed: %d" ), err );

            }

        iReserved &= ~aTarget;

        }

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::DoReleaseLight - return" ) );

    }

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

// CHWRMExtendedLightImpl::HandleGainingForeground     

// Inherited From MCoeForegroundObserver - called when app comes to foreground

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

//

void CHWRMExtendedLightImpl::HandleGainingForeground()

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::HandleGainingForeground()" ) );

    // Reserve if any target is autoreserving

    if ( iAutoReserving )

        {

        TRAP_IGNORE(DoReserveLightL(iAutoReserving, ETrue, EFalse));

        }            

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::HandleGainingForeground - return " ) );

    }

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

// CHWRMExtendedLightImpl::HandleLosingForeground     

// Inherited From MCoeForegroundObserver - called when app goes to background 

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

void CHWRMExtendedLightImpl::HandleLosingForeground()

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::HandleLosingForeground()" ) );

    // Release if any target is autoreserving

    if ( iAutoReserving )

        {

        DoReleaseLight(iAutoReserving);

        }            

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::HandleLosingForeground - return " ) );

    }

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

// CHWRMExtendedLightImpl::LightOnL

// Set light on.

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

//

void CHWRMExtendedLightImpl::LightOnL(TInt aTarget)

    {

    LightOnL(aTarget, KHWRMInfiniteDuration, KHWRMDefaultIntensity, ETrue);

    }

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

// CHWRMExtendedLightImpl::LightOnL

// Set light on for a duration.

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

//

void CHWRMExtendedLightImpl::LightOnL(TInt aTarget, 

                                      TInt aDuration)

    {

    LightOnL(aTarget, aDuration, KHWRMDefaultIntensity, ETrue);

    }

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

// CHWRMExtendedLightImpl::LightOnL

// Set light on for a duration with intensity.

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

//

void CHWRMExtendedLightImpl::LightOnL(TInt aTarget, 

                                      TInt aDuration, 

                                      TInt aIntensity,

		                              TBool aFadeIn)

    {

    COMPONENT_TRACE5(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightOnL(0x%x, 0x%x, 0x%x, 0x%x)" ), aTarget, aDuration, aIntensity, aFadeIn);

    CheckCommonParametersL(aTarget, aDuration, aIntensity);

    // Create package

    THWRMLightsOnData data;

    data.iTarget = aTarget;

    data.iIntensity = aIntensity;

    data.iDuration = aDuration;

    data.iFadeIn = aFadeIn;

    data.iColor =  0; //No color info

    THWRMLightsOnCmdPackage pckg(data);

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMLightsOn, TIpcArgs(&pckg)));

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightOnL - return" ) );

    }

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

// CHWRMExtendedLightImpl::LightBlinkL

// Set light Blinking.

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

//

void CHWRMExtendedLightImpl::LightBlinkL(TInt aTarget)

    {

    LightBlinkL(aTarget, KHWRMInfiniteDuration, KHWRMDefaultCycleTime, KHWRMDefaultCycleTime, KHWRMDefaultIntensity );

    }

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

// CHWRMExtendedLightImpl::LightBlinkL

// Set light Blinking for a duration.

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

//

void CHWRMExtendedLightImpl::LightBlinkL(TInt aTarget, 

                                         TInt aDuration)

    {

    LightBlinkL(aTarget, aDuration, KHWRMDefaultCycleTime, KHWRMDefaultCycleTime, KHWRMDefaultIntensity );

    }

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

// CHWRMExtendedLightImpl::LightBlinkL

// Set light Blinking for a duration with intensity.

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

//

void CHWRMExtendedLightImpl::LightBlinkL(TInt aTarget, 

                                         TInt aDuration, 

                                         TInt aOnDuration, 

                                         TInt aOffDuration, 

                                         TInt aIntensity)

    {

    COMPONENT_TRACE6(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightBlinkL(0x%x, 0x%x, 0x%x, 0x%x, 0x%x)" ), aTarget, aDuration, aOnDuration, aOffDuration, aIntensity);

    CheckCommonParametersL(aTarget, aDuration, aIntensity);

    CheckDurationParameterL(aOnDuration);

    CheckDurationParameterL(aOffDuration);

    // If one of the cycle durations is default, both must be

    if ( aOnDuration == KHWRMDefaultCycleTime || aOffDuration == KHWRMDefaultCycleTime )

        {

        if ( aOnDuration != aOffDuration )

            {

            COMPONENT_TRACE3(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightBlinkL - Default cycle duration mismatch (%d,%d)" ), aOnDuration, aOffDuration );

            User::Leave(KErrArgument);

            }

        }

    // Create package

    THWRMLightsBlinkData blinkData;

    blinkData.iTarget = aTarget;

    blinkData.iIntensity = aIntensity;

    blinkData.iDuration = aDuration;

    blinkData.iOnCycleDuration = aOnDuration;

    blinkData.iOffCycleDuration = aOffDuration;

    THWRMLightsBlinkCmdPackage pckg(blinkData);

    // Call server

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMLightsBlink, TIpcArgs(&pckg)));

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightBlinkL - return" ) );

    }

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

// CHWRMExtendedLightImpl::LightOffL

// Set light off.

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

//

void CHWRMExtendedLightImpl::LightOffL(TInt aTarget)

    {

    LightOffL(aTarget, KHWRMInfiniteDuration, ETrue);

    }

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

// CHWRMExtendedLightImpl::LightOffL

// Set light off for a duration.

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

//

void CHWRMExtendedLightImpl::LightOffL(TInt aTarget, 

                               TInt aDuration)

    {

    LightOffL(aTarget, aDuration, ETrue);

    }

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

// CHWRMExtendedLightImpl::LightOffL

// Set light off for a duration with fadeout period

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

//

void CHWRMExtendedLightImpl::LightOffL(TInt aTarget, 

                                       TInt aDuration, 

		                               TBool aFadeOut)

    {

    COMPONENT_TRACE4(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightOffL(0x%x, 0x%x, 0x%x)" ), aTarget, aDuration, aFadeOut);

    CheckCommonParametersL(aTarget, aDuration, KHWRMDefaultIntensity);

    // Create package

    THWRMLightsOffData data;

    data.iTarget = aTarget;

    data.iDuration = aDuration;

    data.iFadeOut = aFadeOut;

    THWRMLightsOffCmdPackage pckg(data);

    // Call server 

    User::LeaveIfError(iClient.ExecuteOperation(EHWRMLightsOff, TIpcArgs(&pckg, aDuration)));

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightOffL - return" ) );

    }

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

// CHWRMExtendedLightImpl::LightStatus

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

//

CHWRMExtendedLight::TLightStatus CHWRMExtendedLightImpl::LightStatus(TInt aTarget) const

    {

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightStatus(0x%x)" ), aTarget );

    CHWRMExtendedLight::TLightStatus status = CHWRMExtendedLight::ELightStatusUnknown;

    if ( iStatusObserver )

        {

        status = iStatusObserver->CurrentStatus(aTarget);

        }

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::LightStatus - return 0x%x" ), status );

    return status;    

    }

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

// CHWRMExtendedLightImpl::SupportedTargets

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

//

TInt CHWRMExtendedLightImpl::SupportedTargets() const

    {

    COMPONENT_TRACE1(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::SupportedTargets()" ) );

    COMPONENT_TRACE2(_L( "HWRM ExtendedLightClient - CHWRMExtendedLightImpl::SupportedTargets - return 0x%x" ), iSupportedTargets );

    return iSupportedTargets;    

    }