diff -r 000000000000 -r 164170e6151a securitydialogs/Autolock/src/AutoLockModel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/securitydialogs/Autolock/src/AutoLockModel.cpp Tue Jan 26 15:20:08 2010 +0200 @@ -0,0 +1,445 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "AutoLockModelPS.h" +#include "AutolockAppUiPS.h" +#include "AutoLockLockObserverPS.h" +#include "AutoLockCenRepI.h" + + +const TInt AutoLockOff(60000); + + + +// ================= MEMBER FUNCTIONS ======================= +// +// ---------------------------------------------------------- +// CAutoLockModel::NewL() +// ---------------------------------------------------------- +// + +CAutoLockModel* CAutoLockModel::NewL(CAutolockAppUi* aAppUi, TBool aLocked) + { + CAutoLockModel* self = new (ELeave) CAutoLockModel(aAppUi); + CleanupStack::PushL(self); + self->ConstructL( aLocked ); + CleanupStack::Pop(); //self + return self; + } +// +// ---------------------------------------------------------- +// CAutoLockModel::CAutoLockModel() +// C++ default constructor +// ---------------------------------------------------------- +// +CAutoLockModel::CAutoLockModel(CAutolockAppUi* aAppUi) : + iAppUi( aAppUi ), iMonitoring(EFalse) + { + } + +// +// ---------------------------------------------------------- +// CAutoLockModel::ConstructL() +// Symbian OS default constructor +// ---------------------------------------------------------- +// +void CAutoLockModel::ConstructL( TBool aLocked ) + { + FeatureManager::InitializeLibL(); + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::ConstructL() BEGIN")); + #endif + iCenRepI = CAutolockCenRepI::NewL(iAppUi); + // lock status observer + iLockObserver = CLockObserver::NewL(iAppUi); + // Activitymanager + iActivityManager = CUserActivityManager::NewL(CActive::EPriorityStandard); + StartActivityMonitoringL(); + // In GSM the device is always unlocked. + // In CDMA, SecClientUi will lock the device on boot-up if needed. + + if ( aLocked == EAutolockStatusUninitialized ) + { + RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockStatusUninitialized); + } + else + { + RProperty::Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff); + } + + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::ConstructL() END")); + #endif + } + // +// ---------------------------------------------------------- +// CAutoLockModel::StartActivityMonitoringL() +// Start monitoring user activity +// ---------------------------------------------------------- +// +void CAutoLockModel::StartActivityMonitoringL() + { + SetActivityManagerL(); + } + +// +// ---------------------------------------------------------- +// CAutoLockModel::StopActivityMonitoring() +// Stop monitoring user activity +// ---------------------------------------------------------- +// +void CAutoLockModel::StopActivityMonitoring() + { + CancelActivityManager(); + } + +// +// ---------------------------------------------------------- +// CAutoLockModel::SetActivityManagerL() +// Initializes activymanager +// ---------------------------------------------------------- +// +void CAutoLockModel::SetActivityManagerL() + { + if (AutoLockTimeout() ) + { + iActivityManager->Start(AutoLockTimeout(), TCallBack(HandleInactiveEventL,this), + TCallBack(HandleActiveEventL,this)); + } + else + { + iActivityManager->Start(AutoLockOff, TCallBack(HandleInactiveEventL,this), + TCallBack(HandleActiveEventL,this)); + } + + } +// +// ---------------------------------------------------------- +// CAutoLockModel::CancelActivityManager() +// UnInitializes activymanager +// ---------------------------------------------------------- +// +void CAutoLockModel::CancelActivityManager() + { + if ( iActivityManager ) + { + iActivityManager->Cancel(); + } + delete iActivityManager; + iActivityManager = NULL; + } +// +// ---------------------------------------------------------- +// CAutoLockModel::~CAutoLockModel() +// Destructor +// ---------------------------------------------------------- +// +CAutoLockModel::~CAutoLockModel() + { + delete iCenRepI; + delete iLockObserver; + StopActivityMonitoring(); + FeatureManager::UnInitializeLib(); + // close custom phone + } +// +// ---------------------------------------------------------- +// CAutoLockModel::AutoLockTimeout() +// Returns current autolock period +// ---------------------------------------------------------- +// +TInt CAutoLockModel::AutoLockTimeout() + { + return iCenRepI->Timeout(); + } +// +// ---------------------------------------------------------- +// CAutoLockModel::ResetInactivityTimeoutL() +// Gets autolock period and starts monitoring user activity +// ---------------------------------------------------------- +// +void CAutoLockModel::ResetInactivityTimeout() + { + if (AutoLockTimeout() ) + { + iActivityManager->SetInactivityTimeout(AutoLockTimeout()); + } + else + { + iActivityManager->SetInactivityTimeout(AutoLockOff); + } + } +// +// ---------------------------------------------------------- +// CAutoLockModel::HandleActiveEventL() +// Handles Active event. Called by ActivityManager +// ---------------------------------------------------------- +// +TInt CAutoLockModel::HandleActiveEventL(TAny* /*aPtr*/) + { + return KErrNone; + } + +// +// ---------------------------------------------------------- +// CAutoLockModel::HandleInactiveEventL() +// Handles InActive event. Called by ActivityManager +// ---------------------------------------------------------- +// +TInt CAutoLockModel::HandleInactiveEventL(TAny* aPtr) + { + if ( STATIC_CAST(CAutoLockModel*, aPtr)->AutoLockTimeout() ) + { + TInt value(EStartupUiPhaseUninitialized); + RProperty::Get(KPSUidStartup, KPSStartupUiPhase, value); + //Don't lock unless boot is over. + if(value == EStartupUiPhaseAllDone) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::HandleInactiveEventL() Boot over")); + #endif + #ifdef RD_REMOTELOCK + STATIC_CAST(CAutoLockModel*, aPtr)->LockSystemL(ETimerLocked); + #else + STATIC_CAST(CAutoLockModel*, aPtr)->LockSystemL(EAutolockOn); + #endif //RD_REMOTELOCK + } + else + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::HandleInactiveEventL() In boot; don't lock")); + #endif + } + } + return KErrNone; + } + +// +// ---------------------------------------------------------- +// CAutoLockModel::LockSystemL() +// Locks system +// ---------------------------------------------------------- +// +void CAutoLockModel::LockSystemL(TInt aAutolockState) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() BEGIN")); + #endif + // If already locked, do nothing. Otherwise we'll end up + // on top of Screensaver + // Check if iSideKey2 is zero or not (locked if nonzero) + // Also, phone should not be locked if PUK1 code query is up. +#ifdef FF_STARTUP_OMA_DM_SUPPORT // New booting order Start ID: MVKS-7PZDZ5 + TInt autolock_value = 0; + RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolock_value); + if (autolock_value == EAutolockStatusUninitialized) + { + return; + } +#endif //End ID: MVKS-7PZDZ5 + if (iAppUi->Locked() || iAppUi->IsPinBlocked()) + { + return; + } + + TInt lightStatus=EForcedLightsUninitialized; + RProperty::Get(KPSUidCoreApplicationUIs,KLightsVTForcedLightsOn,lightStatus ); + //If display is forced on. don't lock + if(lightStatus == EForcedLightsOn ) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() Display is forced on. Device not locked")); + #endif + return; + } + + //Check which state we are in to see if it's OK to lock the phone + //In CDMA when there is no SIM (RUIM) support we should be able to lock + //the phone after reboot. In this case ESWStateNormal is too late to lock the phone + //and other states below are needed. + TBool okToLock = EFalse; + TInt sysState = 0; + iProperty.Get(KPSUidStartup, KPSGlobalSystemState, sysState); + //If NOT in CDMA the Autolock should come up only after the phone has booted up. + if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) || iAppUi->HiddenReset()) + { + if( (sysState == ESwStateNormalRfOn || + sysState == ESwStateNormalRfOff || + sysState == ESwStateCriticalPhaseOK) && + (aAutolockState > EAutolockOff) ) // EMKK-7N3G7R + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() LOCKED AFTER HIDDEN RESET")); + #endif + okToLock = ETrue; + } + } + else //Feature Manager + { + if( (sysState == ESwStateNormalRfOn || + sysState == ESwStateNormalRfOff) && + (aAutolockState > EAutolockOff) ) // EMKK-7N3G7R + { + okToLock = ETrue; + } + } + TInt tarmFlag; +if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw )) +{ + // Get the TARM admin flag value + TInt tRet = RProperty::Get( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag ); + + if ( tRet != KErrNone ) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL():\ + Warning: failed to get TARM Admin Flag state")); + #endif + } + else + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL(): TARM flag: %d"), + tarmFlag ); + #endif + } +} + + TInt callState; + iProperty.Get(KPSUidCtsyCallInformation, KCTsyCallState, callState); +TBool isConditionSatisfied = EFalse; +if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw )) +{ + if ( ( callState != EPSCTsyCallStateNone ) && (!( tarmFlag & KSCPFlagAdminLock )) ) + isConditionSatisfied = ETrue; +} +else +{ + if ( callState != EPSCTsyCallStateNone ) + isConditionSatisfied = ETrue; +} + if (isConditionSatisfied) + { + TBool remoteLocked(EFalse); + #ifdef RD_REMOTELOCK + remoteLocked = (aAutolockState == ERemoteLocked); + #endif //RD_REMOTELOCK + if(remoteLocked) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() REMOTE LOCKED")); + #endif + okToLock = ETrue; + + } + else + okToLock = EFalse; + } + + if (!iAppUi->IsForeground() && okToLock) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() LOCK PHONE")); + #endif + // close fast-swap window + CEikonEnv::Static()->DismissTaskList(); + // inform Avokon & Other app that system is locked + // unless the value has already been set in secuisystemlock + #ifdef RD_REMOTELOCK + if(aAutolockState != EManualLocked) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() Timer/Remote locked: %d"), aAutolockState); + #endif + SetLockedL(aAutolockState); + } + else if((aAutolockState == EManualLocked) && !iAppUi->Locked() && iAppUi->HiddenReset()) + { //set the PubSub key if we are to be locked after a hidden reset has occurred. + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() HIDDEN RESET LOCK")); + #endif + SetLockedL(aAutolockState); + } + else + { //Normal manual lock from power key. Just set the CenRep key. + iCenRepI->SetLockedL(okToLock); + } + #else //! RD_REMOTELOCK + SetLockedL(aAutolockState); + #endif//RD_REMOTELOCK + // lock keys + iAppUi->LockKeysL(); + // app to foreground + iAppUi->BringAppToForegroundL(); + // Reset inactivity time so that Screensaver gets to + // run again after its timeout. We'll ignore the new + // inactivity timeout, if already locked + User::ResetInactivityTime(); + } + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::LockSystemL() END")); + #endif +} + +// +// ---------------------------------------------------------- +// CAutoLockModel::SetLocked +// Sets lockvalue in Publish & Subscribe and Central Repository +// ---------------------------------------------------------- +// +void CAutoLockModel::SetLockedL(TInt aAutolockState) + { + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() begin")); + #endif + TBool locked = (aAutolockState > EAutolockOff); + if (locked) + { + iProperty.Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, aAutolockState); + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() LOCK")); + #endif + } + else + { + iProperty.Set(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, EAutolockOff); + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() UNLOCK")); + #endif + } + + iCenRepI->SetLockedL(locked); + #if defined(_DEBUG) + RDebug::Print(_L("(AUTOLOCK)CAutoLockModel::SetLockedL() end")); + #endif + } + +// END OF FILE