--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/securitydialogs/Autolock/src/AutolockAppUi.cpp Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,1450 @@
+/*
+* 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 <apgtask.h>
+#include <etelmm.h>
+#include <AknEcs.h>
+#include <aknnotedialog.h>
+#include <aknkeylock.h>
+#include <AknLayoutDef.h>
+#include <AknLayout.lag>
+#include <bldvariant.hrh>
+#include <aknappui.h>
+#include <centralrepository.h>
+#include <settingsinternalcrkeys.h>
+#include <secuisecurityhandler.h>
+#include <secui.h>
+#include <featmgr.h>
+#include <Autolock.rsg>
+#include <mmtsy_names.h>
+#include <e32property.h>
+#include <PSVariables.h> // Property values
+#include <coreapplicationuisdomainpskeys.h>
+#include <startupdomainpskeys.h>
+#include <ctsydomainpskeys.h>
+#include <securityuisprivatepskeys.h>
+#include <AknSgcc.h>
+
+#include "AutolockAppUiPS.h"
+#include "AutoLockValueObserverPS.h"
+#include "AutoLockModelPS.h"
+#include "AutolockApp.h"
+#include "autolock.hrh"
+#include "AutolockView.h"
+
+#include <SCPClient.h>
+#include <AknSoftNotifier.h>
+
+// sysap uid and message enums defined in eikon.hrh
+// for sending messages to sysap
+#include <eikon.hrh>
+#include <apgwgnam.h>
+#include <aknlayoutscalable_avkon.cdl.h>
+
+// LOCAL CONSTANTS AND MACROS
+#define KSysApUid TUid::Uid(0x100058F3)
+
+const TInt KTriesToConnectServer( 2 );
+const TInt KTimeBeforeRetryingServerConnection( 50000 );
+const TInt PhoneIndex( 0 );
+
+// ================= MEMBER FUNCTIONS =======================
+//
+// ----------------------------------------------------------
+// CAutolockAppUi::ConstructL()
+// ?implementation_description
+// ----------------------------------------------------------
+//
+void CAutolockAppUi::ConstructL()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL"));
+ #endif
+
+ BaseConstructL( EAknEnableSkin | EAknEnableMSK );
+
+ //Disable priority control so that Autolock process priority isn't set to "background" by
+ //window server when it is not active.
+ iEikonEnv->WsSession().ComputeMode( RWsSession::EPriorityControlDisabled );
+ RThread().SetProcessPriority( EPriorityHigh );
+
+ FeatureManager::InitializeLibL();
+
+ RTelServer::TPhoneInfo PhoneInfo;
+ // prevent autolock shutdown
+ iEikonEnv->SetSystem( ETrue );
+
+ iSideKey1 = 0;
+ iSideKey2 = 0;
+ iAppKey = 0;
+
+ aCallButtonRect = TRect (0,0,0,0);
+ //connect to ETel
+
+ TInt err( KErrGeneral );
+ TInt thisTry( 0 );
+
+ /*All server connections are tried to be made KTiesToConnectServer times because occasional
+ fails on connections are possible at least on some servers*/
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() connect to etel server"));
+ #endif
+ // connect etel server
+ while ( ( err = iServer.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer )
+ {
+ User::After( KTimeBeforeRetryingServerConnection );
+ }
+ User::LeaveIfError( err );
+
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() load tsy"));
+ #endif
+ // load tsy
+ err = iServer.LoadPhoneModule( KMmTsyModuleName );
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() load tsy ERROR: %d"), err);
+ #endif
+ if ( err != KErrAlreadyExists )
+ {
+ // may return also KErrAlreadyExists if some other
+ // is already loaded the tsy module. And that is
+ // not an error.
+ User::LeaveIfError( err );
+ }
+
+ thisTry = 0;
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() open phone"));
+ #endif
+ //open phone
+ User::LeaveIfError(iServer.SetExtendedErrorGranularity(RTelServer::EErrorExtended));
+ User::LeaveIfError(iServer.GetPhoneInfo(PhoneIndex, PhoneInfo));
+ User::LeaveIfError(iPhone.Open(iServer,PhoneInfo.iName));
+ User::LeaveIfError(iCustomPhone.Open(iPhone));
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() phone opened"));
+ #endif
+
+ TBool systemLocked = EFalse;
+ TBool autolockValue = EAutolockStatusUninitialized;
+
+ iWait = NULL;
+ iWait = CWait::NewL();
+
+ #ifndef __WINS__
+
+
+ /*****************************************************
+ * Series 60 Customer / ETEL
+ * Series 60 ETEL API
+ *****************************************************/
+
+ // set autolock period to 0, if lock is disabled in DOS side
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() set autolock period to 0"));
+ #endif
+ RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);
+
+ iWait->SetRequestType(EMobilePhoneGetLockInfo);
+ iPhone.GetLockInfo(iWait->iStatus, lockType, lockInfoPkg);
+ TInt res = iWait->WaitForRequestL();
+ User::LeaveIfError(res);
+ TInt lockValue = 0;
+ CRepository* repository = CRepository::NewL(KCRUidSecuritySettings);
+ TInt cRresult = repository->Get(KSettingsAutolockStatus, lockValue);
+ TBool hiddenReset = HiddenReset();
+ #if defined(_DEBUG)
+ if(hiddenReset)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() Hidden reset"));
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() CR get result: %d"), cRresult);
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() CR lock value: %d"), lockValue);
+ #endif
+ if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled)
+ {
+ repository->Set(KSettingsAutoLockTime, 0);
+ if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )
+ {
+ repository->Set(KSettingsLockOnPowerUp, 0);
+ }
+ }
+ // In CDMA, the system can stay locked on after the boot-up sequence.
+ else if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) || (hiddenReset && (lockValue == 1)))
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() Hidden reset when locked"));
+ #endif
+ systemLocked = ETrue;
+ }
+
+
+ if ( lockInfo.iSetting == RMobilePhone::ELockSetEnabled && lockValue != EAutolockOff && !hiddenReset)
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() EAutolockStatusUninitialized %d"),EAutolockStatusUninitialized);
+ #endif
+ autolockValue = EAutolockStatusUninitialized;
+ }
+ else if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled || (hiddenReset && (lockValue == 0)) )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() EAutolockOff %d"),EAutolockOff);
+ #endif
+ autolockValue = EAutolockOff;
+ }
+
+ delete repository;
+ #endif //__WINS__
+
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() Enable emergency call support"));
+ #endif
+
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() Autolock view"));
+ #endif
+
+
+
+ // -------------------------------------------------------------------------------------------------------------
+ // part of emergency call handling when telephony+devicelock is active
+ // this solution is meant only for 3.1 and 3.2
+
+ iEcsNote = new (ELeave) CEcsNote();
+ iEcsNote->ConstructSleepingNoteL(R_AVKON_EMERGENCY_CALL_NOTE);
+ iEcsNote->ButtonGroupContainer().ButtonGroup()->AsControl()->DrawableWindow()->SetOrdinalPosition(0,2);
+
+ if (AknLayoutUtils::PenEnabled()) // on touch devices, if Autolock is activated from IdleScreen in landscape, the buttons need to be drawn.
+ {
+ iEcsNote->ButtonGroupContainer().SetCommandL( 0, _L("") ); // as keyboard is locked, these buttons do nothing. Better to hide their labels.
+ iEcsNote->ButtonGroupContainer().SetCommandL( EAknSoftkeyCancel, _L("") );
+ iEcsNote->ButtonGroupContainer().ButtonGroup()->AsControl()->MakeVisible(ETrue);
+ }
+
+ // Emergency call support
+ iEcsDetector = CAknEcsDetector::NewL();
+ iEcsDetector->SetObserver( this );
+ iEmergencySupportReady = ETrue;
+ // -------------------------------------------------------------------------------------------------------------
+
+
+ // Autolock view
+ CAutolockView* lockView = new(ELeave) CAutolockView;
+ CleanupStack::PushL(lockView);
+ lockView->ConstructL();
+ CleanupStack::Pop(); // lockView
+ AddViewL(lockView); // transfer ownership to CAknViewAppUi
+ SetDefaultViewL(*lockView);
+
+ // start autolock timer
+ iModel = CAutoLockModel::NewL(this, autolockValue);
+
+ // phone event observer
+ iPhoneObserver = CValueObserver::NewL(this);
+ //call bubble
+ iIncallBubble = CAknIncallBubble::NewL();
+
+ //Autokeyguard Period observer
+ #ifdef RD_AUTO_KEYGUARD
+ iKeyguardObserver = CAutoKeyguardObserver::NewL();
+ #else //!RD_AUTO_KEYGUARD
+ iKeyguardObserver = NULL;
+ #endif //RD_AUTO_KEYGUARD
+ // Create the write policy. Also processes with write device data can write the value.
+ TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );
+ // Create the read policy. Also processes with read device data can read the value.
+ TSecurityPolicy readPolicy( ECapabilityReadDeviceData );
+
+ TInt tRet = RProperty::Define( KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, RProperty::EInt, readPolicy, writePolicy );
+
+ if ( tRet != KErrNone )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL():\
+ FAILED to define the SECUI query Flag: %d"), tRet);
+ #endif
+ }
+
+ tRet = RProperty::Define( KPSUidSecurityUIs, KSecurityUIsQueryRequestCancel, RProperty::EInt, readPolicy, writePolicy );
+ if ( tRet != KErrNone )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL():\
+ FAILED to define the SECUI query request state Flag: %d"), tRet);
+ #endif
+ }
+
+if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))
+{
+
+ // Define the TARM admin flag.
+
+ tRet = RProperty::Define( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, RProperty::EInt,
+ readPolicy, writePolicy );
+ if ( tRet != KErrNone )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL():\
+ FAILED to define the TARM Admin Flag"));
+ #endif
+ }
+
+ // The following sequence is used to validate the configuration on SCP server.
+ // This is needed on the first boot (initial or RFS) or if the C-drive has been formatted
+ // (3-button format) and Autolock is not active.
+
+ RSCPClient scpClient;
+ if ( scpClient.Connect() == KErrNone )
+ {
+ TInt confStatus = scpClient.CheckConfiguration( KSCPInitial );
+
+ if ( confStatus == KErrAccessDenied )
+ {
+ #ifndef __WINS__
+ if ( ( lockInfo.iSetting == RMobilePhone::ELockSetDisabled ) )
+ #else // __WINS__
+ if ( 1 ) // DOS lock is never active in WINS
+ #endif // __WINS__
+ {
+ // DOS lock is not active. Note that if DOS is locked, checking the code here will
+ // mess up the query sequence. On initial startup DOS is not locked.
+
+ TInt finalConfStatus = scpClient.CheckConfiguration( KSCPComplete );
+
+ if ( finalConfStatus == KErrAccessDenied )
+ {
+ #ifdef __WINS__
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL():\
+ DOS validation FAILED in WINS, something wrong!"));
+ #endif
+ #else // !__WINS__
+
+ // The SCP server is out of sync and Autolock is not active. (c-drive formatted)
+ // We must ask the security code. ( Note that it is very rare that this is executed )
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL():\
+ Lock setting disabled, calling setlocksetting"));
+ #endif
+
+ // Wait here until the startup is complete
+
+ TInt tarmErr = KErrNone;
+ while ( tarmErr == KErrNone )
+ {
+ TInt sysState=0;
+ tarmErr = RProperty::Get(KPSUidStartup, KPSGlobalSystemState, sysState);
+
+ if ((sysState == ESwStateNormalRfOn) || (sysState == ESwStateNormalRfOff)
+ || (sysState == ESwStateNormalBTSap))
+ {
+ break;
+ }
+ User::After(500000);
+ }
+
+ // Just change the lock setting again to disabled to request the security code.
+ // Set the TARM flag so SecUi knows it should display the "login" query.
+ TInt tarmFlag=0;
+ tRet = RProperty::Get( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );
+ if ( tRet == KErrNone )
+ {
+ tarmFlag |= KSCPFlagResyncQuery;
+ tRet = RProperty::Set( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );
+ }
+
+ if ( tRet != KErrNone )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL():\
+ FAILED to set TARM Admin Flag"));
+ #endif
+ }
+
+ RMobilePhone::TMobilePhoneLockSetting lockChange;
+ lockChange = RMobilePhone::ELockSetDisabled;
+ iWait->SetRequestType(EMobilePhoneSetLockSetting);
+ iPhone.SetLockSetting(iWait->iStatus, lockType, lockChange);
+
+ res = iWait->WaitForRequestL();
+ #endif // __WINS__
+ }
+ }
+
+ } // if ( confStatus == KErrAccessDenied )
+
+ scpClient.Close();
+ }
+
+}
+
+ // Eventhough we might lock the device on boot-up (systemLocked == ETrue), we
+ // want to hide the app until the handshake is done. StartUp application will
+ // active the app when it is finished.
+ if( !systemLocked )
+ {// app to background
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() app to background"));
+ #endif
+ TApaTask self(iCoeEnv->WsSession());
+ self.SetWgId(iCoeEnv->RootWin().Identifier());
+ self.SendToBackground();
+ // flush
+ iCoeEnv->WsSession().Flush();
+ }
+ else
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() LOCK SYSTEM"));
+ #endif
+ TInt lockState = 0;
+
+ #ifdef RD_REMOTELOCK
+ lockState = EManualLocked;
+ #else //!RD_REMOTELOCK
+ lockState = EAutolockOn;
+ #endif//RD_REMOTELOCK
+ iModel->LockSystemL(lockState);
+ }
+
+ iGripStatusObserver = CAutolockGripStatusObserver::NewL( this, iEikonEnv->WsSession() );
+ iFpsStatusObserver = CAutolockFpsStatusObserver::NewL( this, iEikonEnv->WsSession() );
+ iDeviceLockQueryStatus = EFalse;
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::ConstructL() END"));
+ #endif
+ }
+// ----------------------------------------------------
+// CAutolockAppUi::~CAutolockAppUi()
+// Destructor
+// Frees reserved resources
+// ----------------------------------------------------
+//
+CAutolockAppUi::~CAutolockAppUi()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::~CAutolockAppUi() BEGIN"));
+ #endif
+
+ if(iWait)
+ {
+ // Cancel active requests
+ if(iWait->IsActive())
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::~CAutolockAppUi() CANCEL REQ"));
+ #endif
+ iPhone.CancelAsyncRequest(iWait->GetRequestType());
+ }
+ }
+ //close ETel connections
+ if (iCustomPhone.SubSessionHandle())
+ iCustomPhone.Close();
+
+ if (iPhone.SubSessionHandle())
+ iPhone.Close();
+
+ if (iServer.Handle())
+ {
+ iServer.UnloadPhoneModule(KMmTsyModuleName);
+ iServer.Close();
+ }
+ delete iModel;
+ delete iPhoneObserver;
+ delete iIncallBubble;
+#ifdef RD_AUTO_KEYGUARD
+ delete iKeyguardObserver;
+#endif
+
+ delete iEcsDetector;
+ delete iEcsNote; // Ecs change
+ delete iWait;
+ FeatureManager::UnInitializeLib();
+ delete iGripStatusObserver;
+ delete iFpsStatusObserver;
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::~CAutolockAppUi() END"));
+ #endif
+ }
+// ----------------------------------------------------
+// CAutolockAppUi::HandleForegroundEventL()
+// Handles foreground event.
+// ----------------------------------------------------
+//
+void CAutolockAppUi::HandleForegroundEventL(TBool aForeground)
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleForegroundEventL()"));
+ #endif
+ if (aForeground )
+ {
+ if (iLocked)
+ {
+ // lock voice key
+ LockSideKeyL();
+ }
+ else
+ {
+ // app back to background
+ TApaTask self(iCoeEnv->WsSession());
+ self.SetWgId(iCoeEnv->RootWin().Identifier());
+ self.SendToBackground();
+ }
+ }
+
+ if (!aForeground && iLocked)
+ {
+ TInt callState=0;
+ TInt simStatus=0;
+ RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState );
+ RProperty::Get(KPSUidStartup, KPSSimStatus, simStatus);
+
+ if (callState == EPSCTsyCallStateNone && simStatus != ESimNotPresent)
+ {
+ // try put autolock back to foreground
+ TApaTask self(iCoeEnv->WsSession());
+ self.SetWgId(iCoeEnv->RootWin().Identifier());
+ self.BringToForeground();
+ }
+ else
+ {
+ // unlock voice key while there is active call
+ UnLockSideKey();
+ }
+ }
+
+ CAknAppUi::HandleForegroundEventL(aForeground);
+
+ }
+
+
+// ----------------------------------------------------
+// CAutolockAppUi::HandleMessageL
+//
+// Handles the TARM command to unlock the phone.
+// ----------------------------------------------------
+//
+MCoeMessageObserver::TMessageResponse CAutolockAppUi::HandleMessageL(
+ TUint32 aClientHandleOfTargetWindowGroup,
+ TUid aMessageUid,
+ const TDesC8& aMessageParameters
+ )
+ {
+
+ if(!FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))
+ {
+ User::Leave(KErrNotSupported);
+ }
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL()"));
+ #endif
+
+ MCoeMessageObserver::TMessageResponse messageResponse( EMessageHandled );
+
+ if ( aMessageUid.iUid == SCP_CMDUID_UNLOCK )
+ {
+ // For security reasons we must check from the SCP server did this
+ // command originate from it.
+ RSCPClient scpClient;
+ if ( scpClient.Connect() == KErrNone )
+ {
+ CleanupClosePushL( scpClient );
+
+ if ( scpClient.QueryAdminCmd( ESCPCommandUnlockPhone ) )
+ {
+ // Switch autolock to BG
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\
+ Admin command received, unlocking"));
+ #endif
+
+ if ( !iLocked )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\
+ Ignoring Unlock message - not locked."));
+ #endif
+ }
+ else
+ {
+ iLocked = EFalse;
+ DisableWGListChangeEventListening();
+ UnLockKeys();
+ iModel->SetLockedL(EFalse);
+ // Disable keyguard after remote unlock
+ RAknKeyLock iKeyLock;
+ TInt tempResult = iKeyLock.Connect();
+ iKeyLock.DisableKeyLock();
+ // end Disable keyguard after remote unlock
+ SwitchToPreviousAppL();
+ }
+ }
+ else
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\
+ Unauthorized attempt to unlock"));
+ #endif
+ }
+
+ CleanupStack::PopAndDestroy(); // scpClient
+ }
+ else
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleMessageL():\
+ Failed to connect to SCP, ignoring unlock-message."));
+ #endif
+
+ }
+ }
+ else // aMessageUid.iUid != SCP_CMDUID_UNLOCK
+ {
+ messageResponse = CAknAppUi::HandleMessageL( aClientHandleOfTargetWindowGroup,
+ aMessageUid,
+ aMessageParameters
+ );
+ }
+
+ return messageResponse;
+ }
+
+
+// ------------------------------------------------------------------------------
+// CAutolockAppUi::::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane)
+// This function is called by the UIKON framework just before it displays
+// a menu pane. Its default implementation is empty, and by overriding it,
+// the application can set the state of menu items dynamically according
+// to the state of application data.
+// ------------------------------------------------------------------------------
+//
+void CAutolockAppUi::DynInitMenuPaneL(
+ TInt /*aResourceId*/,CEikMenuPane* /*aMenuPane*/)
+ {
+ }
+
+void CAutolockAppUi::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+ {
+ RDebug::Printf( "%s %s (%u) value=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, 0 );
+ }
+// ----------------------------------------------------
+// CAutolockAppUi::HandleKeyEventL(
+// const TKeyEvent& aKeyEvent,TEventCode /*aType*/)
+// ----------------------------------------------------
+//
+TKeyResponse CAutolockAppUi::HandleKeyEventL(
+ const TKeyEvent& aKeyEvent,TEventCode aType)
+ {
+ if ( aKeyEvent.iCode == EKeyBell)
+ {
+ HandleCommandL(ESecUiCmdUnlock);
+ return EKeyWasConsumed;
+ }
+
+ TBool featureNoPowerkey = FeatureManager::FeatureSupported( KFeatureIdNoPowerkey );
+ // If power key pressed, tell SysAp about if
+ if( (aKeyEvent.iScanCode == EStdKeyDevice2 && aType == EEventKeyDown )
+ || (aType == EEventKey && featureNoPowerkey && aKeyEvent.iCode == EKeyNo))
+ {
+ SendMessageToSysAp(EEikKeyLockPowerKeyPressed);
+ if ( featureNoPowerkey )
+ {
+ SendMessageToSysAp(EEikKeyLockLightsOnRequest);
+ }
+ }
+ return EKeyWasNotConsumed;
+ }
+
+void CAutolockAppUi::SendMessageToSysAp(TInt aMessage)
+ {
+ RWsSession& ws = iEikonEnv->WsSession();
+ TInt wgId=0;
+ CApaWindowGroupName::FindByAppUid(KSysApUid, ws, wgId);
+ if (wgId)
+ {
+ TWsEvent event;
+ event.SetType(aMessage);
+ event.SetTimeNow();
+ ws.SendEventToWindowGroup(wgId, event);
+ }
+ }
+
+// ----------------------------------------------------
+// HideSoftNotification()
+// dismiss all the pending notes just before asking the unlocking code
+// ----------------------------------------------------
+//
+void HideSoftNotification()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)HideSoftNotification"));
+ #endif
+ CAknSoftNotifier *softNotifier = NULL;
+ TRAPD (err, {
+ softNotifier = CAknSoftNotifier::NewL();
+ softNotifier->AddNotificationL(ESetIdleState, 0);
+ };)
+ delete softNotifier;
+ }
+// CAutolockAppUi::HandleCommandL(TInt aCommand)
+// ----------------------------------------------------
+//
+void CAutolockAppUi::HandleCommandL(TInt aCommand)
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleCommandL()"));
+ #endif
+ switch ( aCommand )
+ {
+ case EEikCmdExit:
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleCommandL() EEikCmdExit"));
+ #endif
+ Exit();
+ break;
+ }
+ case ESecUiCmdUnlock:
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleCommandL() ESecUiCmdUnlock"));
+ #endif
+ // stop observing emergency call event
+ iEmergencySupportReady = EFalse;
+ iEcsDetector->Reset(); // Ecs queue is cleared; keys up til here are forgotten
+ // ask secuity code
+ CSecurityHandler* handler = new (ELeave) CSecurityHandler(iPhone);
+ CleanupStack::PushL(handler);
+ TSecUi::InitializeLibL();
+
+ // Put the lights on when security query is shown
+ SendMessageToSysAp( EEikSecurityQueryLights );
+ HideSoftNotification(); // dismiss all the pending notes just before asking the unlocking code
+
+ TRAPD(err,
+ {
+ iDeviceLockQueryStatus = ETrue;
+ if(handler->AskSecCodeInAutoLockL())
+ {
+ iLocked = EFalse;
+ DisableWGListChangeEventListening();
+ iDeviceLockQueryStatus = EFalse;
+ UnLockKeys();
+ iModel->SetLockedL(EFalse);
+ SwitchToPreviousAppL();
+ }
+ else
+ { // make sure that we will be topmost still
+ iDeviceLockQueryStatus = EFalse;
+ TInt callState;
+ RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
+ if ( callState == EPSCTsyCallStateNone &&
+ !FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )
+ {
+ TApaTask self(CCoeEnv::Static()->WsSession());
+ self.SetWgId(CCoeEnv::Static()->RootWin().Identifier());
+ self.BringToForeground();
+ TBool featureNoPowerkey = FeatureManager::FeatureSupported( KFeatureIdNoPowerkey );
+ if ( featureNoPowerkey )
+ {//set lights on in case user pressed "red button". If he pressed cancel the lights are on anyway so it doesn't matter.
+ SendMessageToSysAp(EEikKeyLockLightsOnRequest);
+ }
+ // we don't want enable lock if call in progress
+ RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
+ TInt keyguardDisableState(ECoreAppUIsDisableKeyguardUninitialized);
+ //If there is alarm on the keyguard status is set to disabled. In that case don't enable keyguard as it will be done by SysAp
+ //after the alarm has been disabled/snoozed. Otherwise the alarm CBA is left under keyguard CBA.
+ RProperty::Get( KPSUidCoreApplicationUIs, KCoreAppUIsDisableKeyguard, keyguardDisableState );
+ if ((callState == EPSCTsyCallStateNone) && (keyguardDisableState != ECoreAppUIsDisableKeyguard))
+ {
+ RAknKeyLock keylock;
+ if ( keylock.Connect() == KErrNone )
+ {
+ keylock.EnableAutoLockEmulation();
+ keylock.Close();
+ }
+ }
+ }
+ }
+ };)
+
+ // start observing emergency call event
+ iEmergencySupportReady = ETrue;
+ CleanupStack::PopAndDestroy(handler); // handler
+ TSecUi::UnInitializeLib(); // secui
+
+ User::LeaveIfError(err);
+
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+// ----------------------------------------------------
+// CAutolockAppUi::SwitchToPreviousAppL()
+// Activates previous app
+//----------------------------------------------------
+//
+void CAutolockAppUi::SwitchToPreviousAppL()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::SwitchToPreviousAppL()"));
+ #endif
+ iEcsDetector->Reset(); // Ecs queue is cleared; keys up til here are forgotten
+ // stop observing phone events
+ iPhoneObserver->Stop();
+ CAknView* view = View(KAutoLockViewId);
+ if(view)
+ {
+ STATIC_CAST(CAutolockView*, view)->MakeVisible(EFalse);
+ }
+ else
+ {
+ #if defined(_DEBUG)
+ RDebug::Printf( "%s %s (%u) no view ????=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, view );
+ #endif
+ }
+ // app to background
+ TApaTask self(iCoeEnv->WsSession());
+ self.SetWgId(iCoeEnv->RootWin().Identifier());
+ self.SendToBackground();
+ // flush
+ iCoeEnv->WsSession().Flush();
+ }
+// ----------------------------------------------------
+// CAutolockAppUi::BringAppToForegroundL()
+// Activates autolock app
+//----------------------------------------------------
+//
+void CAutolockAppUi::BringAppToForegroundL()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL()"));
+ #endif
+ TBool tarmAdminFlag(EFalse);
+ TBool remotelockState(EFalse);
+if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))
+{
+ tarmAdminFlag = TarmState();
+}
+
+#ifdef RD_REMOTELOCK
+ TInt autolockState;
+ RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, autolockState);
+ remotelockState = (autolockState == ERemoteLocked);
+#endif//RD_REMOTELOCK
+ // If TARM admin flag is set, bring Autolock to foreground regardless of call state.
+ if(!tarmAdminFlag)
+ { //If phone has been remote locked bring Autolock to foreground regardless of call state.
+ if(!remotelockState)
+ { // check if there is active call
+ TInt callState;
+ RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
+ if (callState != EPSCTsyCallStateNone )
+ {
+ iModel->SetLockedL(EFalse);
+ iModel->ResetInactivityTimeout();
+ UnLockKeys();
+ return;
+ }
+ }
+
+ }
+
+
+ #ifndef __WINS__
+
+ #ifndef __NO_DOS__
+
+ /*****************************************************
+ * Series 60 Customer / ETEL
+ * Series 60 ETEL API
+ *****************************************************/
+
+ // check that device locked in DOS side too
+ RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;
+ RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+ RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);
+
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL() GetLockInfo"));
+ #endif
+ iWait->SetRequestType(EMobilePhoneGetLockInfo);
+ iPhone.GetLockInfo(iWait->iStatus, lockType, lockInfoPkg);
+ TInt res = iWait->WaitForRequestL();
+ User::LeaveIfError(res);
+ if (iWait->iStatus == KErrNone)
+ {
+ // if not don't lock ui either
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL() KErrNone"));
+ #endif
+ if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled)
+ {
+ iModel->SetLockedL(EFalse);
+ UnLockKeys();
+ return;
+ }
+ }
+ #endif
+
+ #endif
+
+ // in case Telephone-app is topmost, then the user is confused because he sees but can't use it.
+ // therefore it's required to hide it, by sending to background. ETMA-7M8A2Y 20090105
+ if ( AknLayoutUtils::PenEnabled() )
+ {
+ TApaTaskList apaTaskList(CCoeEnv::Static()->WsSession());
+ #define KPhoneAppUid TUid::Uid(0x100058B3)
+
+ TApaTask apaTask = apaTaskList.FindApp(KPhoneAppUid);
+ if (apaTask.Exists())
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAknKeyLockControl::EnableKeylock() Bring phone to background"));
+ #endif
+ // Bring phone to background
+ apaTask.SendToBackground();
+ }
+ }
+
+ iPhoneObserver->Start();
+ iLocked = ETrue;
+ // app to foreground
+ TApaTask self(iCoeEnv->WsSession());
+ self.SetWgId(iCoeEnv->RootWin().Identifier());
+ self.BringToForeground();
+ ActivateLocalViewL(KAutoLockViewId);
+ CAknView* view = View(KAutoLockViewId);
+ if(view)
+ {
+ STATIC_CAST(CAutolockView*, view)->MakeVisible(ETrue);
+ }
+ else
+ {
+ #if defined(_DEBUG)
+ RDebug::Printf( "%s %s (%u) no view ????=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, view );
+ #endif
+ }
+ }
+
+// ----------------------------------------------------
+// CAutolockAppUi::LockKeysL()
+// locks keys
+//----------------------------------------------------
+//
+void CAutolockAppUi::LockKeysL()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::LockKeysL()"));
+ #endif
+ // capture appkey & volume key
+ if (!iAppKey)
+ {
+ RWindowGroup& groupWin=iCoeEnv->RootWin();
+ iAppKey = groupWin.CaptureKeyUpAndDowns(EStdKeyApplication0, 0, 0); // Capture app key
+ }
+ LockSideKeyL();
+ }
+// ----------------------------------------------------
+// CAutolockAppUi::UnLockKeys()
+// unlocks keys
+//----------------------------------------------------
+//
+void CAutolockAppUi::UnLockKeys()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::UnLockKeysL()"));
+ #endif
+ // uncapture appkey
+ if (iAppKey)
+ {
+ RWindowGroup& groupWin=iCoeEnv->RootWin();
+ groupWin.CancelCaptureKeyUpAndDowns(iAppKey);
+ iAppKey = 0;
+ }
+ UnLockSideKey();
+ }
+// ----------------------------------------------------
+// CAutolockAppUi::LockSideKeyL()
+// unlocks side-key
+//----------------------------------------------------
+//
+void CAutolockAppUi::LockSideKeyL()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::LockSideKeyL()"));
+ #endif
+ if (!iSideKey1)
+ {
+ RWindowGroup& groupWin=iCoeEnv->RootWin();
+ iSideKey1 = groupWin.CaptureKey(EKeySide,0,0);
+ iSideKey2 = groupWin.CaptureKeyUpAndDowns(EStdKeyDevice6, 0, 0);
+ }
+ }
+
+// -------------------------------------------------------------------------------------------------------------
+// part of emergency call handling when telephony+devicelock is active
+// this solution is meant only for 3.1 and 3.2
+void CAutolockAppUi::HandleEcsEvent( CAknEcsDetector* aEcsDetector, CAknEcsDetector::TState aState )
+ {
+ switch ( aState )
+ {
+ case CAknEcsDetector::ECompleteMatchThenSendKey:
+ // Do nothing since note will be removed on ECallAttempted event
+ break;
+ case CAknEcsDetector::ECompleteMatch:
+ iEcsNote->SetEmergencyNumber( aEcsDetector->CurrentMatch() );
+
+ // Tell sysAp to switch lights on
+ SendMessageToSysAp( EEikEcsQueryLights );
+
+ iEcsNote->ShowNote();
+ iEcsNote->iNoteOnScreen =ETrue;
+ break;
+ case CAknEcsDetector::EPartialMatch:
+ iEcsNote->SleepNote();
+ break;
+ case CAknEcsDetector::ECallAttempted:
+ iEcsNote->SleepNote();
+ break;
+ case CAknEcsDetector::EEmpty:
+ iEcsNote->SleepNote();
+ break;
+ case CAknEcsDetector::ENoMatch:
+ iEcsNote->SleepNote();
+ break;
+ default:
+ break;
+ }
+ }
+
+CEcsNote::CEcsNote() : iNoteOnScreen( EFalse )
+ {}
+
+void CEcsNote::ConstructSleepingNoteL(TInt aResourceId)
+ {
+ CAknNoteDialog::ConstructSleepingDialogL(aResourceId);
+ }
+
+TInt CEcsNote::ShowNote()
+ {
+ ReportUserActivity();
+ iTimeoutInMicroseconds = CAknNoteDialog::EUndefinedTimeout;
+ iTone = CAknNoteDialog::ENoTone;
+ if (!iNoteOnScreen)
+ {
+ return RouseSleepingDialog();
+ }
+ // return value not used
+ else
+ // return value not used
+ return NULL;
+ }
+
+void CEcsNote::SleepNote()
+ {
+ if (iNoteOnScreen)
+ ExitSleepingDialog(); // Causes flicker to other notes if called when note is not on screen
+ iNoteOnScreen = EFalse;
+ }
+
+TKeyResponse CEcsNote::OfferKeyEventL(const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)
+ {
+ return EKeyWasConsumed;
+ }
+
+void CEcsNote::SetEmergencyNumber( const TDesC& aMatchedNumber )
+ {
+ TRect screen(iAvkonAppUi->ApplicationRect());
+ TAknLayoutRect mainPane;
+ mainPane.LayoutRect(screen, AKN_LAYOUT_WINDOW_main_pane(screen, 0, 1, 1));
+ TAknLayoutRect popupNoteWindow;
+ AknLayoutUtils::TAknCbaLocation cbaLocation( AknLayoutUtils::CbaLocation() );
+ TInt variety( 0 );
+ if ( cbaLocation == AknLayoutUtils::EAknCbaLocationRight )
+ {
+ variety = 5;
+ }
+ else if ( cbaLocation == AknLayoutUtils::EAknCbaLocationLeft )
+ {
+ variety = 8;
+ }
+ else
+ {
+ variety = 2;
+ }
+
+ popupNoteWindow.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::popup_note_window( variety ));
+ TAknLayoutText textRect;
+ textRect.LayoutText(popupNoteWindow.Rect(), AKN_LAYOUT_TEXT_Note_pop_up_window_texts_Line_1(4));
+
+ // Size of a temporary buffer that contains new lines, spaces and
+ // emergency number for a note.
+ TBuf16<KAknEcsMaxMatchingLength+80> number;
+ number.Append('\n');
+ number.Append('\n');
+
+ TInt spaceCharWidthInPixels = textRect.Font()->CharWidthInPixels(' ');
+ if (spaceCharWidthInPixels < 1)
+ {
+ // Avoid divide by zero situation even the space char would have zero length.
+ spaceCharWidthInPixels = 1;
+ }
+
+ TInt length = (textRect.TextRect().Width() - textRect.Font()->TextWidthInPixels(aMatchedNumber))
+ / spaceCharWidthInPixels;
+
+ const TInt matchedNumberLength = aMatchedNumber.Length();
+ const TInt numberLength = number.Length();
+ const TInt numberMaxLength = number.MaxLength();
+
+ if ( numberLength + length + matchedNumberLength > numberMaxLength)
+ {
+ // To make sure that buffer overflow does not happen.
+ length = numberMaxLength - numberLength - matchedNumberLength;
+ }
+ for (int i = 0; i < length ; i++)
+ {
+ number.Append(' ');
+ }
+
+ number.Append(aMatchedNumber);
+ TRAP_IGNORE(SetTextL(number));
+
+ }
+
+// -------------------------------------------------------------------------------------------------------------
+
+// ----------------------------------------------------
+// CAutolockAppUi::UnLockSideKey()
+// unlocks side-key
+//----------------------------------------------------
+//
+void CAutolockAppUi::UnLockSideKey()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::UnLockSideKeyL()"));
+ #endif
+ if (iSideKey1)
+ {
+ RWindowGroup& groupWin=iCoeEnv->RootWin();
+ groupWin.CancelCaptureKeyUpAndDowns(iSideKey2);
+ groupWin.CancelCaptureKey(iSideKey1);
+ iSideKey1 = 0;
+ iSideKey2 = 0;
+ }
+ }
+
+
+//
+// ---------------------------------------------------------
+// CAutolockAppUi::HandleScreenDeviceChangedL()
+// Handles screen layout changes, called by CCoeAppUi
+// ---------------------------------------------------------
+//
+void CAutolockAppUi::HandleScreenDeviceChangedL()
+{
+ CAknAppUiBase::HandleScreenDeviceChangedL();
+ //get autolock view from CAknViewAppUi
+ CAknView* view = View(KAutoLockViewId);
+ if(view)
+ {
+ STATIC_CAST(CAutolockView*, view)->ScreenDeviceChanged();
+ }
+
+}
+
+//
+// ----------------------------------------------------------
+// CAutolockAppUi::IsPinBlocked()
+// Checks whether PIN1/UPIN is blocked
+// ----------------------------------------------------------
+//
+TBool CAutolockAppUi::IsPinBlocked()
+{
+ RMmCustomAPI::TSecurityCodeType secCodeType;
+ TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));
+ TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin ));
+
+ if(wcdmaSupported || upinSupported)
+ {
+ RMobilePhone::TMobilePhoneSecurityCode activePin;
+ iCustomPhone.GetActivePin(activePin);
+ if(activePin == RMobilePhone::ESecurityUniversalPin)
+ secCodeType = RMmCustomAPI::ESecurityUniversalPin;
+ else
+ secCodeType = RMmCustomAPI::ESecurityCodePin1;
+ }
+ else
+ secCodeType = RMmCustomAPI::ESecurityCodePin1;
+
+ TBool isBlocked = EFalse;
+ iCustomPhone.IsBlocked(secCodeType,isBlocked);
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::IsPinBlocked result: %d"), isBlocked);
+ #endif
+ return isBlocked;
+}
+
+//
+// ----------------------------------------------------------
+// CAutolockAppUi::HandleWsEventL()
+//
+// ----------------------------------------------------------
+//
+void CAutolockAppUi::HandleWsEventL( const TWsEvent& aEvent,CCoeControl* aDestination )
+ {
+ const TInt type = aEvent.Type();
+
+ switch ( type )
+ {
+ case KAknFullOrPartialForegroundLost: // partial or full fg lost
+ if( iIncallBubble )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleWsEventL: DISABLE call bubble"));
+ #endif
+ iIncallBubble->SetIncallBubbleAllowedInIdleL( EFalse );
+ }
+ break;
+ case KAknFullOrPartialForegroundGained: // partial or full fg gained
+ if( iIncallBubble )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HandleWsEventL: ENABLE call bubble"));
+ #endif
+ iIncallBubble->SetIncallBubbleAllowedInIdleL( ETrue );
+ }
+ break;
+ case EEventWindowGroupListChanged:
+ HandleWindowGroupListChange();
+ break;
+ case EEventPointer:
+ case EEventDragDrop:
+ {
+ TInt callState = 0;
+ RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
+ if ( 1==1 || callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateUninitialized )
+ {
+ TPointerEvent *pointer = aEvent.Pointer();
+ CAknView* view = View(KAutoLockViewId);
+ if(view)
+ {
+ STATIC_CAST(CAutolockView*, view)->ScreenDeviceChanged();
+ TRect aCallRect;
+ STATIC_CAST(CAutolockView*, view)->HandleCall(1, aCallRect);
+ if(aCallButtonRect.iBr.iX==0)
+ aCallButtonRect = TRect (aCallRect);
+ }
+ if(pointer->iType==TPointerEvent::EButton1Up)
+ {
+ TPoint iPosition = pointer->iPosition;
+ if(aCallButtonRect.iBr.iX<iPosition.iX && iPosition.iX<aCallButtonRect.iBr.iX+aCallButtonRect.iTl.iX && iPosition.iY<400 )
+ {
+ #define KPhoneAppUid1 TUid::Uid(0x100058B3)
+ TApaTaskList tasklist( iCoeEnv->WsSession() );
+ TApaTask phonetask = tasklist.FindApp( KPhoneAppUid1 );
+ if ( phonetask.Exists() )
+ {
+ TRawEvent event;
+ event.Set(TRawEvent::EKeyDown, EStdKeyNo);
+ iEikonEnv->WsSession().SimulateRawEvent(event);
+ User::After(1000);
+ event.Set(TRawEvent::EKeyUp, EStdKeyNo);
+ iEikonEnv->WsSession().SimulateRawEvent(event);
+ }
+ }
+ }
+ }
+ }
+ break;
+ case EEventKeyUp: // on touch devices, this happens only for the switch-key, which should turn on the lights.
+ case EEventKey:
+ case EEventKeyDown:
+ if(iLocked)
+ SendMessageToSysAp( EEikSecurityQueryLights );
+ break;
+ default:
+ break;
+ }
+
+ // All events are sent to base class.
+ CAknViewAppUi::HandleWsEventL( aEvent, aDestination );
+
+ // part of emergency call handling when telephony+devicelock is active
+ // this solution is meant only for 3.1 and 3.2
+ // Emergency detector only handles key down events
+ if ( iEmergencySupportReady )
+ iEcsDetector->HandleWsEventL( aEvent, aDestination);
+ }
+
+TBool CAutolockAppUi::DeviceLockQueryStatus()
+ {
+ return iDeviceLockQueryStatus;
+ }
+
+TBool CAutolockAppUi::DeviceLockStatus()
+ {
+ return iLocked;
+ }
+
+TBool CAutolockAppUi::DeviceFpsLock(TInt iStatus)
+ {
+ if(iStatus)
+ HandleCommandL(ESecUiCmdUnlock);
+ else
+ iModel->SetLockedL(ETimerLocked);
+ return ETrue;
+ }
+void CAutolockAppUi::HandleWindowGroupListChange()
+ {
+ if ( !iLocked )
+ {
+ // System is not locked, make sure app is not on the foreground.
+ if ( !iCoeEnv->RootWin().OrdinalPosition() )
+ {
+ CAknSgcClient::MoveApp(
+ iCoeEnv->RootWin().Identifier(),
+ ESgcMoveAppToBackground );
+ }
+ }
+ else
+ {
+ CAknView* view = View(KAutoLockViewId);
+ if(view)
+ {
+ TRect aCallRect;
+ STATIC_CAST(CAutolockView*, view)->HandleCall(10, aCallRect);
+ if(aCallButtonRect.iBr.iX==0)
+ aCallButtonRect = TRect (aCallRect);
+ }
+ // So now system is locked. When call is not ongoing, autolock should
+ // be on the foreground.
+ TInt callState = 0;
+ RProperty::Get( KPSUidCtsyCallInformation, KCTsyCallState, callState );
+ if ( callState == EPSCTsyCallStateNone ||
+ callState == EPSCTsyCallStateUninitialized )
+ {
+ // No calls ongoing.
+ if ( iCoeEnv->RootWin().OrdinalPosition() > 0 )
+ {
+ // Not on foreground
+ CAknSgcClient::MoveApp(
+ iCoeEnv->RootWin().Identifier(),
+ ESgcMoveAppToForeground );
+ }
+ }
+ }
+ }
+
+TBool CAutolockAppUi::TarmState()
+{
+TBool ret(EFalse);
+if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))
+{
+ // Get the TARM admin flag value
+ TInt tarmFlag;
+ 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
+ }
+
+ // Unset the admin flag if set
+ if ( tarmFlag & KSCPFlagAdminLock )
+ {
+ ret = ETrue;
+ TInt tRet = RProperty::Get( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );
+
+ if ( tRet == KErrNone )
+ {
+ tarmFlag &= ~KSCPFlagAdminLock;
+ tRet = RProperty::Set( KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID, tarmFlag );
+ }
+
+ if ( tRet != KErrNone )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::BringAppToForegroundL(): FAILED to unset TARM Admin Flag"));
+ #endif
+ }
+ }
+
+}
+return ret;
+}
+
+// ---------------------------------------------------------
+// CAutolockAppUi::HiddenReset()
+// ---------------------------------------------------------
+TBool CAutolockAppUi::HiddenReset()
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HiddenReset() begin"));
+ #endif
+
+ TBool ret_val ( EFalse );
+ TInt startupReason(ENormalStartup);
+ TInt errorCode(KErrNone);
+
+ RProperty::Get(KPSUidStartup, KPSStartupReason, startupReason);
+
+ if ( errorCode != KErrNone )
+ {
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HiddenReset() error getting startup reason"));
+ #endif
+ }
+ ret_val = (startupReason != ENormalStartup);
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::HiddenReset() END: %d"), ret_val);
+ #endif
+ return ret_val;
+ }
+void CAutolockAppUi::EnableWGListChangeEventListening()
+{
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::EnableWGListChangeEventListening()"));
+ #endif
+ RWindowGroup& rootWin = iCoeEnv->RootWin();
+ rootWin.EnableGroupListChangeEvents();
+ rootWin.EnableScreenChangeEvents();
+}
+void CAutolockAppUi::DisableWGListChangeEventListening()
+{
+ #if defined(_DEBUG)
+ RDebug::Print(_L("(AUTOLOCK)CAutolockAppUi::DisableWGListChangeEventListening()"));
+ #endif
+ RWindowGroup& rootWin = iCoeEnv->RootWin();
+ rootWin.DisableGroupListChangeEvents();
+ rootWin.DisableScreenChangeEvents();
+}
+// End of File