/*

 * 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