/*
* Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: CSysApLightsController implementation.
*
*/
// INCLUDE FILES
#include <activitymanager.h>
#include "SysApLightsController.h"
#include "SysApAppUi.h"
#include "coreapplicationuisinternalpskeys.h"
#include <e32svr.h>
#include <hwrmdomainpskeys.h>
#include "SysApFeatureManager.h"
#ifdef RD_LIGHT_CONTROL_CHANGE
#include "sysaplightpluginhandler.h"
#endif // RD_LIGHT_CONTROL_CHANGE
#include "SysApFeatureManager.h"
// CONSTANTS
const TInt KLightsOffPeriodLockJustActivated ( 5 ); // 5 sec
const TInt KMaxLightsOffPeriodForScreenSaverAnimation ( 30 ); // 30 sec
const TInt KLightsOnRepeatMinPeriod( 3 ); // Do not set lights on again for concecutive calls within this period (seconds)
const TInt KLightsOnUnlockNotePeriodMs( 1500 ); // 1.5 second timeout when unlock note is shown
#ifdef RD_LIGHT_CONTROL_CHANGE
const TInt KMilliSecondCoefficient = 1000;
#endif // RD_LIGHT_CONTROL_CHANGE
// ========================== MEMBER FUNCTIONS ================================
// ----------------------------------------------------------------------------
// CSysApLightsController* CSysApLightsController::NewL( )
// ----------------------------------------------------------------------------
CSysApLightsController* CSysApLightsController::NewL(CSysApAppUi& aSysApAppUi, const TInt aTimeout, const TBool aCoverDisplay )
{
TRACES( RDebug::Print( _L("CSysApLightsController::NewL") ) );
CSysApLightsController* self = new ( ELeave ) CSysApLightsController( aSysApAppUi, aTimeout, aCoverDisplay );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop(); //self
return self;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ConstructL( )
// ----------------------------------------------------------------------------
void CSysApLightsController::ConstructL( )
{
TRACES( RDebug::Print( _L("CSysApLightsController::ConstructL: lights timeout=%d"), iLightsTimeout ) );
TRACES( RDebug::Print( _L("CSysApLightsController::ConstructL: cover display supported=%d"), iCoverDisplaySupported ) );
iSysApTimer = new ( ELeave ) CSysApTimer( *this );
iLight = CHWRMLight::NewL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler = CSysApLightPluginHandler::NewL();
#endif // RD_LIGHT_CONTROL_CHANGE
iSysApFeatureManager = CSysApFeatureManager::NewL();
EnableActivityManagerL();
SetFlipOpenNoLights( iFlipOpen, ETrue );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EInitialLightsOn );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::CSysApLightsController()
// ----------------------------------------------------------------------------
CSysApLightsController::CSysApLightsController( CSysApAppUi& aSysApAppUi, const TInt aTimeout, const TBool aCoverDisplay )
:
iGripOpen( ETrue ),
iFlipOpen( ETrue ),
iSysApAppUi( aSysApAppUi ),
iLightsTimeout( aTimeout ),
iCoverDisplaySupported( aCoverDisplay ),
iInactivityDetected( EFalse )
#ifdef RD_LIGHT_CONTROL_CHANGE
, iKeyEventsObserved( EFalse )
#endif // RD_LIGHT_CONTROL_CHANGE
{
}
// ----------------------------------------------------------------------------
// CSysApLightsController::~CSysApLightsController()
// ----------------------------------------------------------------------------
CSysApLightsController::~CSysApLightsController()
{
TRACES( RDebug::Print( _L("~CSysApLightsController") ) );
DisableActivityManager();
if ( iSysApTimer )
{
if ( iSysApTimer->IsActive() )
{
iSysApTimer->Cancel();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOffTimerStop,
TPckgBuf<TBool>(EFalse) );
#endif // RD_LIGHT_CONTROL_CHANGE
}
delete iSysApTimer;
}
#ifdef RD_LIGHT_CONTROL_CHANGE
delete iLightPluginHandler;
#endif // RD_LIGHT_CONTROL_CHANGE
delete iLight;
delete iSysApFeatureManager;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::AlarmOccuredL( const TBool aAlarmActive )
// ----------------------------------------------------------------------------
void CSysApLightsController::AlarmOccuredL( const TBool aAlarmActive )
{
TRACES( RDebug::Print( _L("CSysApLightsController::AlarmOccuredL: %d"), aAlarmActive ) );
iAlarmAlerting = aAlarmActive;
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EAlarmState, TPckgBuf<TBool>(aAlarmActive) );
#endif // RD_LIGHT_CONTROL_CHANGE
TBool blinkEnabled = ETrue;
if( iSysApFeatureManager->Supported( KSysApFeatureIdNoFlasUiInSilentMode ))
{
blinkEnabled = EFalse;
}
// Incoming call overrides alarm when lights are concerned
if( !iCallRinging && aAlarmActive )
{
ReserveLightL();
SetLightsOnL( blinkEnabled ); // set lights blinking (if enabled)
}
else
{
SetLightsOnL( iCallRinging && iSilent && blinkEnabled ); // keep on blinking if call is ringing in silent mode
ReleaseLight();
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::AccessoryConnectedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::AccessoryConnectedL( TBool aConnected )
{
TRACES( RDebug::Print( _L("CSysApLightsController::AccessoryConnectedL()" ) ) );
if ( aConnected && !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EAccessoryConnection, TPckgBuf<TBool>(aConnected) );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EAccessoryConnection, TPckgBuf<TBool>(aConnected) );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ChargerConnectedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::ChargerConnectedL( TBool aConnected )
{
TRACES( RDebug::Print( _L("CSysApLightsController::ChargerConnectedL(): aConnected=%d" ), aConnected ) );
TBool isLocked( iSysApAppUi.DeviceLockState() || iSysApAppUi.KeyLockState() );
// if the device is not locked user activity will switch on the lights upon charger removal
if ( ((!isLocked && aConnected) || isLocked ) && !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EChargerConnection, TPckgBuf<TBool>(aConnected) );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EChargerConnection, TPckgBuf<TBool>(aConnected) );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ChargingCompleteL()
// ----------------------------------------------------------------------------
void CSysApLightsController::ChargingCompleteL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::ChargingCompleteL()" ) ) );
if ( !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EChargingComplete );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EChargingComplete );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ProfileChangedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::ProfileChangedL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::ProfileChangedL()" ) ) );
// If device is not locked, activity event turns on lights.
if ( ( iSysApAppUi.DeviceLockState() || iSysApAppUi.KeyLockState() ) && !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EProfileChanged );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EProfileChanged );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::MemoryCardInsertedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::MemoryCardInsertedL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::MemoryCardInsertedL()" ) ) );
if ( !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EMemoryCardInserted );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EMemoryCardInserted );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::CallComingInL( const TBool aCallringing )
// ----------------------------------------------------------------------------
void CSysApLightsController::CallComingInL( const TBool aCallringing )
{
TRACES( RDebug::Print( _L("CSysApLightsController::CallComingInL: %d"), aCallringing ) );
iCallRinging = aCallringing;
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ECallStateRinging, TPckgBuf<TBool>(aCallringing) );
#endif // RD_LIGHT_CONTROL_CHANGE
if( aCallringing )
{
ReserveLightL();
// Incoming call overrides alarm when lights are concerned
if( iSilent )
{
// default we want blink while in call
TBool blink = ETrue;
// in some touch products we don't want lights to blink while call is incoming
if( iSysApFeatureManager->Supported( KSysApFeatureIdNoFlasUiInSilentMode ) )
{
blink = EFalse;
}
SetLightsOnL( blink ); // set lights blinking
}
else
{
SetLightsOnL();
}
}
else
{
SetLightsOnL();
ReleaseLight();
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::PowerKeyPressedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::PowerKeyPressedL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::PowerKeyPressedL()") ) );
if ( !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EPowerKeyPressed );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
else
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EPowerKeyPressed );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetGripOpenL( const TBool aOpen )
// ----------------------------------------------------------------------------
void CSysApLightsController::SetGripOpenL( const TBool aOpen )
{
TRACES( RDebug::Print( _L("CSysApLightsController::SetGripOpenL( aOpen:%d )"), aOpen ) );
iGripOpen = aOpen;
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EGripOpenState, TPckgBuf<TBool>(aOpen) );
#endif // RD_LIGHT_CONTROL_CHANGE
TurnOffInactiveTargetsL();
SetLightsOnL();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetFlipOpenL( const TBool aOpen )
// ----------------------------------------------------------------------------
void CSysApLightsController::SetFlipOpenL( const TBool aOpen )
{
TRACES( RDebug::Print( _L("CSysApLightsController::SetFlipOpenL( aOpen:%d )"), aOpen ) );
SetFlipOpenNoLights( aOpen, EFalse );
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EFlipOpenState, TPckgBuf<TBool>(aOpen) );
#endif // RD_LIGHT_CONTROL_CHANGE
TurnOffInactiveTargetsL();
SetLightsOnL();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetSilentModeOn( const TBool aSilent )
// ----------------------------------------------------------------------------
void CSysApLightsController::SetSilentModeOn( const TBool aSilent )
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ESilentMode, TPckgBuf<TBool>(aSilent) );
#endif // RD_LIGHT_CONTROL_CHANGE
iSilent = aSilent;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::HandleLightsRequireL( )
// ----------------------------------------------------------------------------
void CSysApLightsController::HandleLightsRequireL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleLightsRequireL" ) ) );
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsRequire );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::HandleRawKeyEventLightsRequireL
// ----------------------------------------------------------------------------
void CSysApLightsController::HandleRawKeyEventLightsRequireL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleLightsRequireL" ) ) );
// This request comes from NspsWsPlugin via System Application Notification API
if ( !iSysApAppUi.DeviceLockState() && !iSysApAppUi.KeyLockState()
#ifdef RD_LIGHT_CONTROL_CHANGE
&& iKeyEventsObserved
#endif // RD_LIGHT_CONTROL_CHANGE
)
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsRequireRawKeyEvent );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsRequireRawKeyEvent );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::HandleForcedLightsVTRequireL( const TInt aLightParameter )
// ----------------------------------------------------------------------------
void CSysApLightsController::HandleForcedLightsVTRequireL( const TInt aLightsParameter )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleForcedLightsVTRequireL: aLightsParameter: %d" ), aLightsParameter ) );
iForcedLightsOn = aLightsParameter != EForcedLightsOn ? EFalse : ETrue;
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsForcedVideoTel,
TPckgBuf<TBool>(aLightsParameter == EForcedLightsOn) );
#endif // RD_LIGHT_CONTROL_CHANGE
if ( aLightsParameter != EForcedLightsOn)
{
ReleaseLight();
}
else
{
ReserveLightL();
}
SetLightsOnL();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::HandleForcedLightsSSRequireL( const TInt aLightParameter )
// ----------------------------------------------------------------------------
void CSysApLightsController::HandleForcedLightsSSRequireL( const TInt aLightsParameter )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleForcedLightsSSRequireL: aLightsParameter: %d" ), aLightsParameter ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsForcedScreenSaver,
TPckgBuf<TBool>(aLightsParameter > 0) );
#endif // RD_LIGHT_CONTROL_CHANGE
if ( aLightsParameter == 0)
{
SetLightsOffL();
}
else if ( aLightsParameter > 0 )
{
SetDisplayLightsOnWithoutResettingInactivityTimersL();
iSysApTimer->ActivateTimerL( KMaxLightsOffPeriodForScreenSaverAnimation );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOffTimerStart,
TPckgBuf<TInt>( KMaxLightsOffPeriodForScreenSaverAnimation*KMilliSecondCoefficient ) );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::HandleForcedLightsATCRequireL( const TInt aLightParameter )
// ----------------------------------------------------------------------------
void CSysApLightsController::HandleForcedLightsATCRequireL( const TInt aLightsParameter )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleForcedLightsATCRequireL: aLightsParameter: %d" ), aLightsParameter ) );
if ( aLightsParameter != EForcedLightsOn )
{
TRACES( RDebug::Print( _L( "Cancel inactivity timer" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EInactivityDetected );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOffL();
}
else
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EActivityDetected );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::DeviceLockStateChangedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::DeviceLockStateChangedL( TBool aEnabled )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::DeviceLockStateChangedL(): aEnabled=%d" ), aEnabled ) );
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EDeviceLockState, TPckgBuf<TBool>(aEnabled) );
#endif // RD_LIGHT_CONTROL_CHANGE
EnableActivityManagerL(aEnabled);
if ( aEnabled )
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction ); // complete previous event
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsExplicitlyOffWithDelayL();
}
else
{
ReportUserActivity();
if ( !Alerting() )
{
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction ); // complete previous event
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::KeylockStateChangedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::KeylockStateChangedL( TBool aEnabled )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::KeylockStateChangedL(): aEnabled=%d" ), aEnabled ) );
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EKeyLockState, TPckgBuf<TBool>(aEnabled) );
#endif // RD_LIGHT_CONTROL_CHANGE
EnableActivityManagerL(aEnabled);
if ( aEnabled )
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction ); // complete previous event
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsExplicitlyOffWithDelayL();
}
else
{
ReportUserActivity();
if ( !Alerting() )
{
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction ); // complete previous event
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SwitchLightsOnSoftRejectL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SwitchLightsOnSoftRejectL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SwitchLightsOnSoftRejectL()" ) ) );
ReportUserActivity();
// When soft reject is used in silent mode, the lights are set on because otherwise
// blinking light disturb user when they are using phone UI
if ( ( !iCallRinging || ( iCallRinging && iSilent ) )
&& !iAlarmAlerting )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsOnSoftReject );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOnSoftReject );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLightsExplicitlyOffWithDelayL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLightsExplicitlyOffWithDelayL()
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsOffTimerStart,
TPckgBuf<TInt>(KLightsOffPeriodLockJustActivated*KMilliSecondCoefficient) );
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
#endif // RD_LIGHT_CONTROL_CHANGE
iSysApTimer->ActivateTimerL( KLightsOffPeriodLockJustActivated );
}
// ----------------------------------------------------------------------------
// CSysApLightsController::CancelLightsExplicitlyOffWithDelayL()
// ----------------------------------------------------------------------------
void CSysApLightsController::CancelLightsExplicitlyOffWithDelayL()
{
if ( iSysApTimer->IsActive() )
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOffTimerStop,
TPckgBuf<TBool>(EFalse) );
#endif // RD_LIGHT_CONTROL_CHANGE
iSysApTimer->Cancel();
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLightsOnUnlockNoteL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLightsOnUnlockNoteL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOnUnlockNoteL()" ) ) );
if ( !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsOnUnlockNote );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
iSysApTimer->ActivateMsTimerL( KLightsOnUnlockNotePeriodMs );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOffTimerStart,
TPckgBuf<TBool>(KLightsOnUnlockNotePeriodMs) );
#endif // RD_LIGHT_CONTROL_CHANGE
}
else
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOnUnlockNote );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLightsOnEcsQueryL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLightsOnEcsQueryL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::SetLightsOnEcsQueryL()") ) );
if ( !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsOnEcsQuery );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
else
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOnEcsQuery );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLightsOnSecurityQueryL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLightsOnSecurityQueryL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::SetLightsOnSecurityQueryL()") ) );
if ( !Alerting() )
{
CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsOnSecQuery );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOnL();
}
else
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::ELightsOnSecQuery );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::DoLightsTimeoutChangedL()
// ----------------------------------------------------------------------------
void CSysApLightsController::DoLightsTimeoutChangedL( const TInt aTimeout )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::DoLightsTimeoutChangedL(): aTimeout=%d" ), aTimeout ) );
if ( aTimeout < KMinimumLightsTimeout )
{
iLightsTimeout = KMinimumLightsTimeout;
}
else if ( aTimeout > KMaximumLightsTimeout )
{
iLightsTimeout = KMaximumLightsTimeout;
}
else
{
iLightsTimeout = aTimeout;
}
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EInactivityTimeoutChanged,
TPckgBuf<TInt>(iLightsTimeout*KMilliSecondCoefficient) );
#endif // RD_LIGHT_CONTROL_CHANGE
EnableActivityManagerL(); // activity manager reset
}
// ----------------------------------------------------------------------------
// CSysApLightsController::EnableActivityManagerL()
// ----------------------------------------------------------------------------
void CSysApLightsController::EnableActivityManagerL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::EnableActivityManager: lights timeout: %d sec" ), iLightsTimeout ) );
if ( iActivityManager )
{
DisableActivityManager();
}
iActivityManager = CUserActivityManager::NewL( CActive::EPriorityStandard );
iActivityManager->Start( iLightsTimeout,
TCallBack( HandleInactiveEventL, this ),
TCallBack( HandleActiveEventL, this ) );
}
// ----------------------------------------------------------------------------
// CSysApLightsController::EnableActivityManagerL(TBool aIsLocked)
// ----------------------------------------------------------------------------
void CSysApLightsController::EnableActivityManagerL(TBool aIsLocked)
{
TRACES( RDebug::Print( _L( "CSysApLightsController::EnableActivityManager: isLocked: %d " ), aIsLocked ) );
if ( iActivityManager )
{
DisableActivityManager();
}
iActivityManager = CUserActivityManager::NewL( CActive::EPriorityStandard );
if(aIsLocked)
{
iActivityManager->Start( KMinimumLightsTimeout,
TCallBack( HandleInactiveEventL, this ),
TCallBack( HandleActiveEventL, this ) );
TRACES( RDebug::Print( _L( "CSysApLightsController::EnableActivityManager: locked: lights timeout: %d sec" ),
KMinimumLightsTimeout ) );
}
else
{
iActivityManager->Start( iLightsTimeout ,
TCallBack( HandleInactiveEventL, this ),
TCallBack( HandleActiveEventL, this ) );
TRACES( RDebug::Print( _L( "CSysApLightsController::EnableActivityManager: not locked: lights timeout: %d sec" ),
iLightsTimeout ) );
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::DisableActivityManager()
// ----------------------------------------------------------------------------
void CSysApLightsController::DisableActivityManager()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::DisableActivityManager()" ) ) );
if ( iActivityManager )
{
iActivityManager->Cancel();
delete iActivityManager;
iActivityManager = NULL;
}
}
// ----------------------------------------------------------------------------
// TInt CSysApLightsController::HandleActiveEventL( TAny* aPtr )
// ----------------------------------------------------------------------------
TInt CSysApLightsController::HandleActiveEventL( TAny* aPtr )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleActiveEvent" ) ) );
CSysApLightsController* lightsController = static_cast<CSysApLightsController*>(aPtr);
lightsController->iInactivityDetected = EFalse;
if ( !lightsController->Alerting() && !lightsController->iForcedLightsOn )
{
TBool locked = lightsController->iSysApAppUi.DeviceLockState()
|| lightsController->iSysApAppUi.KeyLockState();
if ( !locked )
{
lightsController->CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
lightsController->iLightPluginHandler->HandleEvent( SysApLightExtension::EActivityDetected );
#endif // RD_LIGHT_CONTROL_CHANGE
lightsController->SetLightsOnL();
return KErrNone;
}
else if ( lightsController->iSysApAppUi.SysApFeatureManager().LockedStateLightsSupported() )
{
// lights on only if they are not already on
if ( !lightsController->iLightsCurrentlyOn )
{
lightsController->CancelLightsExplicitlyOffWithDelayL();
#ifdef RD_LIGHT_CONTROL_CHANGE
lightsController->iLightPluginHandler->HandleEvent( SysApLightExtension::EActivityDetected );
#endif // RD_LIGHT_CONTROL_CHANGE
lightsController->SetLockedStatePrimaryLightsL();
return KErrNone;
}
}
}
#ifdef RD_LIGHT_CONTROL_CHANGE
lightsController->iLightPluginHandler->HandleEventNoAction( SysApLightExtension::EActivityDetected );
#endif // RD_LIGHT_CONTROL_CHANGE
return KErrNone;
}
// ----------------------------------------------------------------------------
// TInt CSysApLightsController::HandleInactiveEventL( TAny* aPtr )
// ----------------------------------------------------------------------------
TInt CSysApLightsController::HandleInactiveEventL( TAny* aPtr )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::HandleInactiveEvent" ) ) );
CSysApLightsController* lightsController = STATIC_CAST( CSysApLightsController*, aPtr );
lightsController->iInactivityDetected = ETrue;
#ifdef RD_LIGHT_CONTROL_CHANGE
lightsController->iLightPluginHandler->HandleEvent( SysApLightExtension::EInactivityDetected );
#endif // RD_LIGHT_CONTROL_CHANGE
if ( !lightsController->Alerting() && !lightsController->iForcedLightsOn )
{
lightsController->SetLightsOffL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
lightsController->iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
}
#endif // RD_LIGHT_CONTROL_CHANGE
return KErrNone;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ReportUserActivity()
// ----------------------------------------------------------------------------
void CSysApLightsController::ReportUserActivity() const
{
TRACES( RDebug::Print( _L( "CSysApLightsController::ReportUserActivity" ) ) );
User::ResetInactivityTime();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::BatteryEmptyL()
// ----------------------------------------------------------------------------
void CSysApLightsController::BatteryEmptyL( TBool aEmpty )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::BatteryEmptyL: aEmpty=%d" ), aEmpty ) );
iBatteryEmpty = aEmpty;
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::EBatteryEmptyState, TPckgBuf<TBool>(aEmpty) );
#endif // RD_LIGHT_CONTROL_CHANGE
if ( aEmpty )
{
SetLightsOffL();
}
#ifdef RD_LIGHT_CONTROL_CHANGE
else
{
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
}
#endif // RD_LIGHT_CONTROL_CHANGE
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLightsOffL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLightsOffL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOffL: iBatteryEmpty=%d, iLightsCurrentlyOn=%d, iForcedLightsOn=%d" ),
iBatteryEmpty, iLightsCurrentlyOn, iForcedLightsOn ) );
if ( !iBatteryEmpty && iForcedLightsOn )
{
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
#endif // RD_LIGHT_CONTROL_CHANGE
return;
}
TInt err(KErrNone);
#ifdef RD_LIGHT_CONTROL_CHANGE
if ( !iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandOff ) )
{
TRAP(err, iLight->LightOffL(CHWRMLight::ESystemTarget));
}
#else // RD_LIGHT_CONTROL_CHANGE
TRAP(err, iLight->LightOffL(CHWRMLight::ESystemTarget));
#endif // RD_LIGHT_CONTROL_CHANGE
// Ignore unreserved in use warnings.
if ( err != KErrNone && err != KErrInUse )
{
// Only trace as leaving here accomplishes nothing.
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOffL failed: err: %d" ), err ) );
}
iLightsCurrentlyOn = EFalse;
#ifdef __SYSAP_MODULE_TEST
iSysApAppUi.Beep();
#endif
#ifndef RD_LIGHT_CONTROL_CHANGE
iSysApAppUi.ActivateKeyeventForwardingForLights(ETrue);
#else // RD_LIGHT_CONTROL_CHANGE
iKeyEventsObserved = ETrue;
#endif // RD_LIGHT_CONTROL_CHANGE
if ( iSysApAppUi.SysApFeatureManager().LockedStateLightsSupported() )
{
// If low intensity lights are supported in locked state, then the lights must be set on with low intensity
// as until active timeout has been reached
// Otherwise we may end up into a situation where lights are not lit because activity cannot be detected without first entering
// inactive state
if ( !iInactivityDetected ) // inactivity not yet detected, so use small intensity lights
{
TBool locked = iSysApAppUi.DeviceLockState() || iSysApAppUi.KeyLockState();
if ( locked ) // applied only if the device is in locked state
{
SetLockedStatePrimaryLightsL();
}
}
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLightsOnL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLightsOnL( TBool aBlinking )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOnL: aBlinking=%d, iGripOpen=%d, iFlipOpen=%d" ),
aBlinking, iGripOpen, iFlipOpen ) );
ReportUserActivity();
if( iBatteryEmpty )
{
SetLightsOffL();
return;
}
#ifndef RD_LIGHT_CONTROL_CHANGE
// Deactivate raw keyevent forwarding as those are only interesting when lights are off due inactivity.
iSysApAppUi.ActivateKeyeventForwardingForLights(EFalse);
#else // RD_LIGHT_CONTROL_CHANGE
iKeyEventsObserved = EFalse;
#endif // RD_LIGHT_CONTROL_CHANGE
TInt err(KErrNone);
if ( aBlinking )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOnL - LIGHTS BLINK" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
if ( !iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandBlink ) )
{
TRAP(err, iLight->LightBlinkL(CHWRMLight::ESystemTarget));
}
#else // RD_LIGHT_CONTROL_CHANGE
TRAP(err, iLight->LightBlinkL(CHWRMLight::ESystemTarget));
#endif // RD_LIGHT_CONTROL_CHANGE
// Do not remember this lights on, if lights were set to blink (as next normal lights on must be done anyway)
iLightsCurrentlyOn = EFalse;
}
else
{
// Filter excess consequtive lights on calls within short time period as they are likely to be caused by same event.
TTime now;
now.HomeTime();
if ( !iLightsCurrentlyOn || ( iAllowLightsOn && (iLastLightsOnTime <= now - TTimeIntervalSeconds(KLightsOnRepeatMinPeriod) ) )
|| Alerting() )
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOnL - LIGHTS ON" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
if ( iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandOn ) )
{
return;
}
#endif // RD_LIGHT_CONTROL_CHANGE
TRAP(err, iLight->LightOnL(CHWRMLight::ESystemTarget));
if ( err == KErrNone )
{
iLightsCurrentlyOn = ETrue;
iLastLightsOnTime.HomeTime();
}
}
else
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOnL - LIGHTS ON denied - Not necessary" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
if ( err != KErrNone )
{
// Only trace as leaving here accomplishes nothing.
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLightsOnL failed: err: %d" ), err ) );
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetDisplayLightsOnWithoutResettingInactivityTimersL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetDisplayLightsOnWithoutResettingInactivityTimersL()
{
if( iBatteryEmpty )
{
SetLightsOffL();
return;
}
TInt err(KErrNone);
TRACES( RDebug::Print( _L( "CSysApLightsController::SetDisplayLightsOnWithoutResettingInactivityTimersL LIGHTS ON" ) ) );
TTime now;
now.HomeTime();
if ( !iLightsCurrentlyOn || ( iAllowLightsOn && (iLastLightsOnTime <= now - TTimeIntervalSeconds(KLightsOnRepeatMinPeriod) ) ) )
{
#ifdef RD_LIGHT_CONTROL_CHANGE
if ( iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandOn ) )
{
return;
}
#endif // RD_LIGHT_CONTROL_CHANGE
TRAP(err, iLight->LightOnL(CHWRMLight::ESystemTarget));
if ( err != KErrNone )
{
// Only trace as leaving here accomplishes nothing.
TRACES( RDebug::Print( _L( "CSysApLightsController::SetDisplayLightsOnWithoutResettingInactivityTimersL failed err: %d" ), err ) );
}
else
{
iLightsCurrentlyOn = ETrue;
iLastLightsOnTime.HomeTime();
}
}
else
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetDisplayLightsOnWithoutResettingInactivityTimersL - LIGHTS ON denied - Not necessary" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::TimerExpiredL()
// ----------------------------------------------------------------------------
void CSysApLightsController::TimerExpiredL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::TimerExpiredL" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleEvent( SysApLightExtension::ELightsOffTimerStop, TPckgBuf<TBool>(ETrue) );
#endif // RD_LIGHT_CONTROL_CHANGE
SetLightsOffL();
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ReserveLightL()
// ----------------------------------------------------------------------------
void CSysApLightsController::ReserveLightL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::ReserveLightL: iReserved=%d" ), iReserved ) );
if ( !iReserved )
{
iLight->ReserveLightL( CHWRMLight::ESystemTarget, EFalse, ETrue);
iReserved = ETrue;
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ReleaseLight()
// ----------------------------------------------------------------------------
void CSysApLightsController::ReleaseLight()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::ReleaseLight(): iCallRinging=%d, iAlarmAlerting=%d, iForcedLightsOn=%d" ),
iCallRinging, iAlarmAlerting, iForcedLightsOn ) );
if ( !Alerting() && !iForcedLightsOn)
{
iLight->ReleaseLight(CHWRMLight::ESystemTarget);
iReserved = EFalse;
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::AllowLightsOn()
// ----------------------------------------------------------------------------
void CSysApLightsController::AllowLightsOn()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::AllowLightsOn: iAllowLightsOn=%d" ), iAllowLightsOn ) );
iAllowLightsOn = ETrue;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetFlipOpenNoLights( const TBool aOpen, const TBool aFetchFlipStatus )
// ----------------------------------------------------------------------------
void CSysApLightsController::SetFlipOpenNoLights( const TBool aOpen, const TBool aFetchFlipStatus )
{
// if aReadFlipStatus is ETrue, aOpen is ignored and flip status is read directly from P&S key
TRACES( RDebug::Print( _L("CSysApLightsController::SetFlipOpenNoLights( aOpen:%d, aFetchFlipStatus:%d )"),
aOpen, aFetchFlipStatus ) );
if ( aFetchFlipStatus )
{
TInt err;
TInt flipStatus;
err = RProperty::Get( KPSUidHWRM, KHWRMFlipStatus, flipStatus );
if ( err )
{
TRACES( RDebug::Print( _L("CSysApLightsController::SetFlipOpenNoLights. RProperty::Get: err=%d."), err ) );
return;
}
if ( flipStatus == EPSHWRMFlipOpen || flipStatus == EPSHWRMFlipStatusUninitialized )
{
iFlipOpen = ETrue;
}
TRACES( RDebug::Print( _L("CSysApLightsController::SetFlipOpenNoLights: KHWRMFlipStatus read, flipStatus=%d"), flipStatus ) );
}
else
{
iFlipOpen = aOpen;
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::TurnOffInactiveTargetsL
// ----------------------------------------------------------------------------
//
void CSysApLightsController::TurnOffInactiveTargetsL()
{
TRACES( RDebug::Print( _L("CSysApLightsController::TurnOffInactiveTargetsL: iFlipOpen=%d, iGripOpen=%d, iCoverDisplaySupported=%d"),
iFlipOpen, iGripOpen, iCoverDisplaySupported ) );
TInt turnoffTarget = CHWRMLight::ENoTarget;
// Then turn off inactive lights depending on device configuration
// Flip state is interesting only when cover display is supported
if ( iCoverDisplaySupported )
{
if ( iFlipOpen )
{
turnoffTarget = CHWRMLight::ESecondaryDisplayAndKeyboard;
}
else
{
turnoffTarget = CHWRMLight::EPrimaryDisplayAndKeyboard;
}
}
else
{
if ( !iFlipOpen )
{
turnoffTarget = CHWRMLight::EPrimaryKeyboard;
}
}
if ( iGripOpen )
{
// No action, grip is open or not supported
}
else
{
turnoffTarget |= CHWRMLight::EPrimaryKeyboard;
}
// Don't try to turn off unsupported targets
turnoffTarget &= iLight->SupportedTargets();
if ( turnoffTarget != CHWRMLight::ENoTarget )
{
TRACES( RDebug::Print( _L("CSysApLightsController::TurnOffInactiveTargetsL: turnoffTarget=0x%x"), turnoffTarget ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
if ( iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandOff ) )
{
iLightsCurrentlyOn = EFalse; // ensure that forthcoming commands set lights on
return;
}
#endif // RD_LIGHT_CONTROL_CHANGE
TRAPD(err, iLight->LightOffL( turnoffTarget, KHWRMInfiniteDuration, EFalse ) );
if ( err != KErrNone )
{
TRACES( RDebug::Print(_L("CSysApLightsController::TurnOffInactiveTargetsL: Turning off inactive targets failed") ) );
}
}
iLightsCurrentlyOn = EFalse;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::SetLockedStatePrimaryLightsL()
// ----------------------------------------------------------------------------
void CSysApLightsController::SetLockedStatePrimaryLightsL()
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLockedStatePrimaryLightsL" ) ) );
TInt err(KErrNone);
TInt target = ResolveLockedStateLightTarget();
// Turn lights on if allowed by CSysApAppUi (to reduce boottime calls).
if ( iAllowLightsOn && (target != CHWRMLight::ENoTarget) )
{
TInt intensity = iSysApAppUi.SysApFeatureManager().LockedStateLightsIntensity();
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLockedStatePrimaryLightsL - LIGHTS ON: target=%d intensity=%d"), target, intensity ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
if ( iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandOn ) )
{
return;
}
#endif // RD_LIGHT_CONTROL_CHANGE
TRAP(err, iLight->LightOnL( CHWRMLight::ESystemTarget, // always use system target, resolved target is used only for denying light command
KHWRMInfiniteDuration,
intensity,
ETrue ) );
}
else
{
TRACES( RDebug::Print( _L( "CSysApLightsController::SetLockedStatePrimaryLightsL LIGHTS ON denied - Not necessary" ) ) );
#ifdef RD_LIGHT_CONTROL_CHANGE
iLightPluginHandler->HandleCommand( SysApLightExtension::ELightCommandNoAction );
#endif // RD_LIGHT_CONTROL_CHANGE
}
}
// ----------------------------------------------------------------------------
// CSysApLightsController::ResolveLockedStateLightTarget()
// ----------------------------------------------------------------------------
TInt CSysApLightsController::ResolveLockedStateLightTarget() const
{
TRACES( RDebug::Print( _L( "CSysApLightsController::ResolveLockedStateLightTarget" ) ) );
// This is a bit questionable whether SysAp should take any considerations about the target now when
// system target is in use. However, alternative way would be to define a new API into HWRM for handling this situation.
TInt target(CHWRMLight::ESystemTarget); // always allow system target, except when a device with Cover UI has flip closed
if ( iCoverDisplaySupported && !iFlipOpen )
{
target = CHWRMLight::ENoTarget;
}
return target;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::GetHwrmLight()
// ----------------------------------------------------------------------------
//
CHWRMLight* CSysApLightsController::GetHwrmLight()
{
return iLight;
}
// ----------------------------------------------------------------------------
// CSysApLightsController::Alerting()
// The device is alerting, either due to a call or an alarm
// ----------------------------------------------------------------------------
//
TBool CSysApLightsController::Alerting() const
{
return iAlarmAlerting || iCallRinging;
}
#ifdef RD_LIGHT_CONTROL_CHANGE
// ----------------------------------------------------------------------------
// CSysApLightsController::KeyEventForwardingReady()
//
// ----------------------------------------------------------------------------
//
void CSysApLightsController::KeyEventForwardingReady()
{
iSysApAppUi.ActivateKeyeventForwardingForLights( ETrue );
}
#endif // RD_LIGHT_CONTROL_CHANGE
// End of File