diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/hwrmlight.h --- a/epoc32/include/hwrmlight.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/hwrmlight.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,709 @@ -hwrmlight.h +/* +* 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 + +// 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 // 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 // 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