/*
* Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
* which accompanies this distribution, and is available
* at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  This file contains the header of the 
*                CHWRMLight class.
*
*/


#ifndef HWRMLIGHT_H
#define HWRMLIGHT_H

// INCLUDES
#include <e32base.h>

// CONSTANTS

/**
* Minimum allowed intensity setting for Light.
*/
const TInt KHWRMLightMinIntensity = 1;

/**
* Maximum allowed intensity setting for Light.
*/
const TInt KHWRMLightMaxIntensity = 100;

/**
* Indicates default intensity in various methods.
*/
const TInt KHWRMDefaultIntensity = 0;

/**
* Maximum allowed duration value.
*/
const TInt KHWRMLightMaxDuration = (KMaxTInt / 1000) - 1;

/**
* Infinite duration value.
*/
const TInt KHWRMInfiniteDuration = 0;

/**
* Indicates device default Blink cycle time.
*/
const TInt KHWRMDefaultCycleTime = 0;


// FORWARD DECLARATIONS
class MHWRMLightObserver;

// CLASS DECLARATIONS

/**
* The class used to control the device lights.
*
* The HW Resource Manager Light API is a library API providing the ability 
* to control the various light targets of the device. The API provides also
* methods to retrieve the current light status and the supported light targets
* of the device. The API is meant for all applications which need to control 
* lights of the device.
*
* Type of the HW Resource Manager Light API is a synchronous method call meaning 
* the method call will block the client application. Every new call of the light
* API method stops all ongoing light control orders. Light state after duration
* based orders expire is the state specified by the last non-duration based order. 
*
* The API consist of the classes CHWRMLight and MHWRMLightObserver. If the client
* requires up-to-date status information, it should also provide callback pointer
* of the MHWRMLightObserver implementing class for the NewL-method.
*
* Usage:
*
* @code
* #include <HWRMLight.h>  // link against HWRMLightClient.lib
*
* // A CHWRMLight instance can be created by using NewL() or NewLC() methods. 
* // Up-to-date status information not required, no callbacks.
* CHWRMLight* light = CHWRMLight::NewL();
*
* // After this, lights can be directly controlled via the provided class methods. 
* light-> LightOnL (EPrimaryDisplay, 5000); // Turn display lights on for five seconds.
* light->LightOffL(EPrimaryDisplay); // Turn display lights off indefinitely.
*
* // To clean up, delete the created object:
* delete light;
* @endcode
*
* @lib HWRMLIGHTCLIENT.DLL
* @since S60 3.0
*/
class CHWRMLight : public CBase
    {
    public:

		/**
		* Possible light states that can be get for the different light targets
		*/
		enum TLightStatus
			{
			ELightStatusUnknown = 0, ///< For debugging/development and signaling an error conditions.
			ELightOn,                ///< Light state switch to light on.
			ELightOff,               ///< Light state switch to light off.
			ELightBlink            ///< Light state switch to light blinking.
			};

        /**
        * Possible light targets. 
        * Targets can be used as bitmask. Some common masks are provided as enum.
        * 
        * Note that all targets are not supported by all devices.
        * Attempting to use unsupported target will result in
        * KErrNotSupported.
        *
        * At least one target must be defined.
        */
        enum TLightTarget
            {
            ENoTarget                    = 0x0,     ///< No target. Not a valid target value, used only
                                                    ///< for error checking.
            
            EPrimaryDisplay              = 0x1,     ///< Primary display of the device.
            EPrimaryKeyboard             = 0x2,     ///< Primary keyboard of the device. 
            EPrimaryDisplayAndKeyboard   = 0x3,     ///< Both primary display and the 
                                                    ///< primary keyboard of the device.  
            
            ESecondaryDisplay            = 0x4,     ///< Secondary display of the device.
            ESecondaryKeyboard           = 0x8,     ///< Secondary keyboard of the device. 
            ESecondaryDisplayAndKeyboard = 0xC,     ///< Both secondary display and the 
                                                    ///< secondary keyboard of the device.  
                                                
            ECustomTarget1               = 0x10,    ///< Device specific custom target 1.
            ECustomTarget2               = 0x20,    ///< Device specific custom target 2.
            ECustomTarget3               = 0x40,    ///< Device specific custom target 3.
            ECustomTarget4               = 0x80,    ///< Device specific custom target 4.
            
            /**
            * Special target used to control all currently available system lights.
            *
            * System lights normally include all displays and keyboards, 
            * but not custom lights. This is however device dependent.
            *
            * A target mask including this target is 
            * always changed to a device state specific target mask. 
            * Note that the  system target with any other target is not supported. 
            *
            * This target is always supported but it is never
            * included in supported targets mask.
            *
            * @see CHWRMLight::SupportedTargets()
            */
            ESystemTarget                = 0x80000000  
            };
            
    public:  // Constructors
        
        /**
        * Two-phased constructor.
        *
        * @return A pointer to a new instance of the CHWRMLight class.
        *
        * @leave KErrNotSupported Device doesn't support Light feature.
        * @leave KErrNoMemory There is a memory allocation failure. 
        */
        IMPORT_C static CHWRMLight* NewL();
        
        /**
        * Two-phased constructor. 
        * Leaves instance to cleanup stack.
        *
        * @return A pointer to a new instance of the CHWRMLight class.
        *
        * @leave KErrNotSupported Device doesn't support Light feature.
        * @leave KErrNoMemory There is a memory allocation failure. 
        */
        IMPORT_C static CHWRMLight* NewLC();

        /**
        * Two-phased constructor.
        * Use this method for creating a Light client with callbacks.
        *
        * @param aCallback Pointer to the callback instance.
        * @return A pointer to a new instance of the CHWRMLight class.
        *
        * @leave KErrNotSupported Device doesn't support Light feature.
        * @leave KErrNoMemory There is a memory allocation failure. 
        */
        IMPORT_C static CHWRMLight* NewL(MHWRMLightObserver* aCallback);
        
        /**
        * Two-phased constructor. 
        * Use this method for creating a Light client with callbacks.
        * Leaves instance to cleanup stack.
        *
        * @param aCallback Pointer to the callback instance
        * @return A pointer to a new instance of the CHWRMLight class.
        *
        * @leave KErrNotSupported Device doesn't support Light feature.
        * @leave KErrNoMemory There is a memory allocation failure. 
        */
        IMPORT_C static CHWRMLight* NewLC(MHWRMLightObserver* aCallback);

    public: // New functions

    	
    	/**
    	* Reserves light target exclusively for this client.
    	* A higher priority client may cause lower priority client reservation
    	* to be temporarily suspended. Commands can still be issued in suspended 
    	* state, but they will not be acted upon unless suspension is lifted
    	* within specified duration.
    	* The suspended client will not get any notification about suspension.
    	* If light target is already reserved by a higher or equal priority application, 
    	* reserving will still succeeds, but reservation is immediately suspended.
    	*
    	* Calling this method is equal to calling ReserveLightL( aTarget, EFalse, EFalse),
    	* i.e. any previously frozen state will not be restored and CCoeEnv
    	* background/foreground status is always used to control further reservations.
    	*
		* @param aTarget Defines which light should be reserved. Multiple lights can
		*                be specified with using bitwise-or.
    	*
    	* @leave KErrNotSupported One or more of specified targets are not supported.
    	* @leave KErrAccessDenied No CCoeEnv present.
    	* @leave KErrNotReady Trying to reserve while on background.
        * @leave KErrNoMemory There is a memory allocation failure. 
		*
	 	* @see TLightTarget
    	*/
    	virtual void ReserveLightL(TInt aTarget)=0;
    	
    	/**
    	* Reserves light target exclusively for this client.
    	* A higher priority client may cause lower priority client reservation
    	* to be temporarily suspended. Commands can still be issued in suspended 
    	* state, but they will not be acted upon unless suspension is lifted
    	* within specified duration.
    	* The suspended client will not get any notification about suspension.
    	* If light target is already reserved by a higher or equal priority application, 
    	* reserving will still succeeds, but reservation is immediately suspended.
    	*
    	*
		* @param aTarget Defines which light should be reserved. Multiple lights can
		*                be specified with using bitwise-or.
    	* @param aRestoreState If ETrue, the state frozen on last release will be
    	*                      restored upon successful reservation.
    	*                      I.e. if light was blinking when it was released by this
        *                      client the last time, it would start blinking again upon
        *                      successful reservation.
    	*                      For the first reservation of each session this parameter 
        *                      is always considered EFalse regardless of what is supplied,
        *                      as there is no previous frozen state to restore.
    	* @param aForceNoCCoeEnv If EFalse, then reservation requires that this client is
        *                        on the foreground at the time of reservation and light
        *                        target will be automatically released and re-reserved based
        *                        on background/foreground status of the this client. This 
        *                        also implies that CCoeEnv::Static() != NULL is required.
    	*                        If ETrue, the client will not require CCoeEnv to be present
        *                        nor does it automatically reserve/release light by depending
        *                        on foreground/background status of the client.
        *                        Only trusted clients are allowed to set this flag to ETrue.
    	*                        A client is considered trusted if it has nonstandard
        *                        priority defined in the internal lights policy of the 
        *                        HW Resource Manager. A client can be defined trusted
        *                        only by S60 or a product.
    	*
    	* @leave KErrNotSupported One or more of specified targets are not supported.
    	* @leave KErrAccessDenied Paramenter aForceNoCCoeEnv is ETrue and client is not trusted.
    	* @leave KErrBadHandle Parameter ForceNoCCoeEnv is EFalse and no CCoeEnv present.
    	* @leave KErrNotReady Trying to reserve while on background and parameter 
        *                     aForceNoCCoeEnv is EFalse.
        * @leave KErrNoMemory There is a memory allocation failure. 
		*
	 	* @see TLightTarget
    	*/
    	virtual void ReserveLightL(TInt aTarget, TBool aRestoreState, TBool aForceNoCCoeEnv)=0;

    	/**
    	* Releases light target if it was previously reserved for this client.
    	* If this client has not reserved any of the specified lights, 
    	* this method does nothing.
    	* Any reserved light targets that are released and have no other suspended
    	* clients will be reset to default state, which is either lights on or lights off, 
    	* depending on system inactivity time.
    	*
		* @param aTarget Defines which light should be released. Multiple lights can
		*                be specified with using bitwise-or.
		*
	 	* @see TLightTarget
    	*/
    	virtual void ReleaseLight(TInt aTarget)=0;


	    /** 
	    * The LightOnL method switches the specified target light on
	    * for infinite duration using default intensity. Lights will use fade-in.
        *
        * Calling this method is equal to calling 
        * LightOnL(aTarget, KHWRMInfiniteDuration, KHWRMDefaultIntensity, ETrue).
	    *
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		*
    	* @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightOnL(TInt aTarget) = 0;

	    /** 
	    * The LightOnL method switches the specified target light on
	    * for the specified duration using default intensity. Lights will use fade-in.
        *
        * Calling this method is equal to call 
        * LightOnL(aTarget, aDuration, KHWRMDefaultIntensity, ETrue).
	    *
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		* @param aDuration Duration of the time the light is switched on measured in milliseconds.
		*                  After the duration expires, the light state for target will be changed 
		*                  to whatever state was caused by the last infinite time duration call, or
		*                  default state determined by inactivity timer, in case there has not 
		*                  been a previous infinite time duration call in this session.
		*                  If the aDuration time is KHWRMInfiniteDuration then it means an 
        *                  infinite value that has to be stopped by calling of any of the other
        '                  light control methods.
		*                  Duration can have maximum value of KHWRMLightMaxDuration.
		*
        * @leave KErrArgument Parameter aDuration is out of range.
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightOnL(TInt aTarget, 
		                      TInt aDuration) = 0;

	    /** 
	    * The LightOnL method switches the specified target light on
	    * for the specified duration using specified intensity. Fade-in can also be controlled.
	    *
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		* @param aDuration Duration of the time the light is switched on measured in milliseconds.
		*                  After the duration expires, the light state for target will be changed 
		*                  to whatever state was caused by the last infinite time duration call, or
		*                  default state determined by inactivity timer, in case there has not 
		*                  been a previous infinite time duration call in this session.
		*                  If the aDuration time is KHWRMInfiniteDuration then it means 
        *                  an infinite value that has to be stopped by calling of any of 
        *                  the other light control methods.
		*                  Duration can have maximum value of KHWRMLightMaxDuration.
		* @param aIntensity Intensity of the light. If aIntensity is KHWRMDefaultIntensity, device default 
		*                   intensity will be used. 
		*                   Note: All devices might not support user defined intensity, in which case
		*                   device will behave in its default fashion.
		* @param aFadeIn If ETrue, lights will not turn on instantly but instead smoothly fade-in.
		*                Note: All devices will not support fade-in, in which case device will
		*                behave in its default fashion.
		*
        * @leave KErrArgument One of the parameters is out of range.
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightOnL(TInt aTarget, 
		                      TInt aDuration, 
		                      TInt aIntensity,
		                      TBool aFadeIn) = 0;

	    /** 
	    * The LightBlinkL method blinks the target light(s) of the device for infinite duration
	    * using default intensity.
        *
        * Calling this method is equal to call 
        * LightBlinkL(aTarget, KHWRMInfiniteDuration, KHWRMDefaultCycleTime, 
        *             KHWRMDefaultCycleTime, KHWRMDefaultIntensity).
	   	*
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
	   	*
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightBlinkL(TInt aTarget) = 0;

	    /** 
	    * The LightBlinkL method blinks the target light(s) of the device for specified duration
	    * using default intensity.
        *
        * Calling this method is equal to calling
        * LightBlinkL(aTarget, aDuration, KHWRMDefaultCycleTime, 
        *             KHWRMDefaultCycleTime, KHWRMDefaultIntensity).
	   	*
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		* @param aDuration Duration of the time the light is set to blink measured in milliseconds.
		*                  After the duration expires, the light state for target will be changed 
		*                  to whatever state was caused by the last infinite time duration call, or
		*                  default state determined by inactivity timer, in case there has not 
		*                  been a previous infinite time duration call in this session.
		*                  If the aTotalDuration time is KHWRMInfiniteDuration then it
		*                  means an infinite value that has to be
		*                  stopped by calling of any of the other light control methods.
		*                  Duration can have maximum value of KHWRMLightMaxDuration.
	   	*
        * @leave KErrArgument Parameter aDuration is out of range.
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightBlinkL(TInt aTarget, 
		                         TInt aDuration) = 0;

	    /** 
	    * The LightBlinkL method blinks the target light(s) of the device for specified duration
	    * using specified intensity. On- and Off-cycle times of the blinking can also be controlled.
	   	*
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		* @param aDuration Duration of the time the light is set to blink measured in milliseconds.
		*                  After the duration expires, the light state for target will be changed 
		*                  to whatever state was caused by the last infinite time duration call, or
		*                  default state determined by inactivity timer, in case there has not 
		*                  been a previous infinite time duration call in this session.
		*                  If the aTotalDuration time is KHWRMInfiniteDuration then it
		*                  means an infinite value that has to be
		*                  stopped by calling of any of the other light control methods.
		*                  Duration can have maximum value of KHWRMLightMaxDuration.
	   	* @param aOnDuration Duration time, measured in milliseconds, of how long the Light is
	   	*                    switched on in every Blink cycle.
		*                    Duration can have maximum value of KHWRMLightMaxDuration.
		*                    For device default cycle duration, use value KHWRMDefaultCycleTime.
		*                    If either of aOnDuration or aOffDuration is KHWRMDefaultCycleTime,
		*                    both must be KHWRMDefaultCycleTime.
		*                    Some devices might not support variable blink cycle times, in which
		*                    case default value will be substituted.
	   	* @param aOffDuration Duration time, measured in milliseconds, of how long the Light
	   	*                     is switched off in every Blink cycle.
		*                     Duration can have maximum value of KHWRMLightMaxDuration.
        *                     For device default cycle duration, use value KHWRMDefaultCycleTime.
        *                     If either of aOnDuration or aOffDuration is KHWRMDefaultCycleTime,
		*                     both must be KHWRMDefaultCycleTime.
		*                     Some devices might not support variable blink cycle times, in which
		*                     case default value will be substituted.
		* @param aIntensity Intensity of the light. If aIntensity is KHWRMDefaultIntensity, device default 
		*                   intensity will be used.
		*                   Note: All devices might not support user defined intensity, in which case
		*                   device will behave in its default fashion.
	   	*
        * @leave KErrArgument One of the parameters is out of range or otherwise invalid.
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightBlinkL(TInt aTarget, 
		                         TInt aDuration, 
		                         TInt aOnDuration, 
		                         TInt aOffDuration, 
		                         TInt aIntensity) = 0;

   	    /**
	    * The LightOffL method switches the device light off for the specified target for
	    * infinite duration. Lights will be switched off with fade-out. 
        *
        * Calling this method is equal to call 
        * LightOffL(aTarget, KHWRMInfiniteDuration, ETrue).
		*
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		*
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightOffL(TInt aTarget) = 0;

   	    /**
	    * The LightOffL method switches the device light off for the specified target for
	    * the specified duration time. Lights will be switched off with fade-out.
        *
        * Calling this method is equal to call LightOffL(aTarget, aDuration, ETrue).
		*
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		* @param aDuration Duration of the time the light is switched off measured in milliseconds.
		*                  After the duration expires, the light state for target will be changed 
		*                  to whatever state was caused by the last infinite time duration call, or
		*                  default state determined by inactivity timer, in case there has not 
		*                  been a previous infinite time duration call in this session.
		*                  If the aDuration time is KHWRMInfiniteDuration then it 
		*                  means an infinite value that has to be
		*                  stopped by calling of any of the other light control methods.
		*                  Duration can have maximum value of KHWRMLightMaxDuration.
		*
        * @leave KErrArgument Parameter aDuration is out of range.
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightOffL(TInt aTarget, 
		                       TInt aDuration) = 0;

   	    /**
	    * The LightOffL method switches the device light off for the specified target for
	    * the specified duration time. Lights fade-out can also be controlled.
		*
		* @param aTarget Defines which light should be controlled. Multiple lights can
		*                be specified with using bitwise-or.
		* @param aDuration Duration of the time the light is switched off measured in milliseconds.
		*                  After the duration expires, the light state for target will be changed 
		*                  to whatever state was caused by the last infinite time duration call, or
		*                  default state determined by inactivity timer, in case there has not 
		*                  been a previous infinite time duration call in this session.
		*                  If the aDuration time is KHWRMInfiniteDuration then it 
		*                  means an infinite value that has to be
		*                  stopped by calling of any of the other light control methods.
		*                  Duration can have maximum value of KHWRMLightMaxDuration.
		* @param aFadeOut If ETrue, lights will not turn off instantly but instead smoothly fade-out
		*                 Note: All devices will not support fade-out, in which case device will
		*                 behave in its default fashion.
		*
        * @leave KErrArgument aDuration is out of range.
        * @leave KErrNotSupported One or more of specified targets are not supported.
        * @leave KErrBadHandle Light session has been invalidated.
        * @leave KErrTimedOut Timeout occurred in controlling light.
        * @leave KErrInUse One or more of specified targets are not reserved for
        *                  this client but are reserved for others.
        * @leave KErrNoMemory There is a memory allocation failure. 
        * @leave KErrGeneral There is a hardware error.
		*
	 	* @see TLightTarget
		*/
		virtual void LightOffL(TInt aTarget, 
		                       TInt aDuration, 
		                       TBool aFadeOut) = 0;
		                       
        /**
        * This method retrieves the current light status. 
        *
		* @param aTarget Defines which light status is returned. 
		*                This method only supports single target, as different
		*                targets might have different statuses.
        * @return TLightStatus indicating the current light status. If there is a problem or
        *         multiple targets were specified, CHWRMLight::ELightStatusUnknown is returned.
        * 
        * @see MHWRMLightObserver
	 	* @see TLightTarget
        */
        virtual TLightStatus LightStatus(TInt aTarget) const = 0;
        
        /**
        * This method retrieves the supported light targets of the device.
        * Any attempt to use or reserve unsupported targets will fail with
        * KErrNotSupported.
        *
        * @return Bitmask containing supported light targets.
        *
        * @see TLightTarget
        */
        virtual TInt SupportedTargets() const = 0;
    };
    
/**
* A callback interface for light status reporting.
*
* If the client requires up-to-date status information, the client needs 
* to derive a class from the MHWRMlightObserver interface and implement 
* the LightStatusChanged() method. 
* 
* A callback object header example:
*
* @code 
* // INCLUDES
* #include <HWRMLight.h> // Link against HWRMLightClient.lib.
*
* class CTests : public CBase,
*                public MHWRMLightObserver
*     {
*     public:
*         CTests();
*         ~CTests();
*                           
*         void ConstructL();
*         static CTests* NewL();
*                
*         // from MHWRMLightObserver
*         virtual void LightStatusChanged(TInt aTarget, 
*                                         CHWRMLight::TLightStatus aStatus);
*
*    private:
*         CHWRMLight* iLight;
*    };
*
* @endcode
*
* A callback method implementation example:
*
* @code
* void CTests::LightStatusChanged(TInt aTarget, 
*                          CHWRMLight::TLightStatus aStatus)
*     {
*     RDebug::Print(_L("### Light state changed for target: 0x%x"), aTarget);
*     switch ( aStatus )
*         {
*         case CHWRMLight::ELightOn:
*             RDebug::Print(_L("### Light state changed: ELightOn"));
*             break;
*         case CHWRMLight::ELightOff:
*             RDebug::Print(_L("### Light state changed: ELightOff"));
*             break;
*         case CHWRMLight::ELightBlink:
*             RDebug::Print(_L("### Light state changed: ELightBlink"));
*             break;
*         case CHWRMLight::ELightStatusUnknown:
*             RDebug::Print(_L("### Light state changed: ELightStatusUnknown"));
*             break;
*         default:
*             RDebug::Print(_L("### Light state changed: UNDEFINED !"));
*             break;
*         }
*     }
*
* @endcode
*
* @since S60 3.0
*/
class MHWRMLightObserver
    {    
    public:
        
        /** 
        * Called when the device light status changes.
        * Note that if the light status for certain target changes
        * very rapidly, some state transitions might be missed.
        * It is however guaranteed that latest state is always obtained.
        *
        * @param aTarget Indicates target(s) the new status applies to.
        * @param aStatus Indicates light request status.
		*
	 	* @see CHWRMLight::TLightTarget
	 	* @see CHWRMLight::TLightStatus
		*/
        virtual void LightStatusChanged(TInt aTarget, 
                                        CHWRMLight::TLightStatus aStatus) = 0;
	};


#endif      // HWRMLIGHT_H   
            
// End of File
