--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/securitydialogs/lockapp/src/lockappstatecontrol.cpp Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,945 @@
+/*
+* Copyright (c) 2007 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: Controls lock states (unlocked, keylock, devicelock)
+ *
+*/
+
+
+#include "lockappstatecontrol.h"
+
+// child controls
+#include "lockappidlecontrol.h"
+#include "lockappkeyguardcontrol.h"
+#include "lockappdevicelockcontrol.h"
+
+#include "lockapppubsubobserver.h"
+#include "lockappcenrepobserver.h"
+
+#include "lockappkeycapturecontroller.h"
+#include "lockappstatepublisher.h"
+#include "lockappecsdetector.h"
+#include "lockapputils.h"
+#include <featmgr.h>
+
+#include <settingsinternalcrkeys.h>
+#include <ScreensaverInternalPSKeys.h>
+#include <ctsydomainpskeys.h>
+#include <activeidle2domainpskeys.h>
+
+#include "GlobalWindowPriorities.h"
+
+#include <avkon.rsg> // general avkon resources
+#include <aknnotpi.rsg> // keyguard spesific resources
+#include <aknsoundsystem.h>
+#include <AknIncallBubbleNotify.h> // incall bubble
+#include <bautils.h> // BaflUtils
+#include <apgwgnam.h>
+
+#include <keylockpolicyapi.h>
+
+#include <hwrmdomainpskeys.h>
+ TUid KUidFpsCategory = {0x1020507E};
+const TInt KFpsAuthenticationKey = 1;
+
+// used avkon dialog resources
+_LIT(KRESOURCEFILE, "z:\\resource\\aknnotpi.rsc");
+
+// Visibility gate WG priority's relative offset from ECoeWinPriorityAlwaysAtFront
+// Now equals -1000 to be an absolute 0.
+const TInt KGlobalWindowPriority_LockVisibilityGate = -1000;
+
+// ---------------------------------------------------------------------------
+// Standard Symbian OS construction sequence
+// ---------------------------------------------------------------------------
+CLockAppStateControl* CLockAppStateControl::NewL( )
+ {
+ CLockAppStateControl* self = new (ELeave) CLockAppStateControl();
+ CleanupStack::PushL( self );
+ self->ConstructL( );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// Destruction releases key captures.
+// ---------------------------------------------------------------------------
+CLockAppStateControl::~CLockAppStateControl( )
+ {
+ // localized resources are freed
+ if ( iResourceFileOffset )
+ {
+ // We implicitely trust that eikon env exists (though in practice it does not make the
+ // difference as this destructor is really never called...)
+ iEikonEnv->DeleteResourceFile(iResourceFileOffset);
+ }
+
+ // PuSub observers
+ if ( iPSScreenSaverObserver )
+ {
+ delete iPSScreenSaverObserver;
+ iPSScreenSaverObserver = NULL;
+ }
+
+ if ( iPSTelephonyObserver )
+ {
+ delete iPSTelephonyObserver;
+ iPSTelephonyObserver = NULL;
+ }
+
+ if ( iPSGripObserver )
+ {
+ delete iPSGripObserver;
+ iPSGripObserver = NULL;
+ }
+
+ if ( iPSFPSObserver )
+ {
+ delete iPSFPSObserver;
+ iPSFPSObserver = NULL;
+ }
+
+ CLockAppKeyCaptureController::Destroy( );
+
+ if ( iIncallBubble )
+ {
+ delete iIncallBubble;
+ iIncallBubble = NULL;
+ }
+
+ if ( iSoundsMuted )
+ {
+ MuteSounds( EFalse );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// The uninitialized status is ELockNoteActive.
+// ---------------------------------------------------------------------------
+CLockAppStateControl::CLockAppStateControl( ) :
+ iLockStatus( ELockNotActive),
+ iWGEventGate( iEikonEnv->RootWin()),
+ iEnvState( 0 )
+ {
+ // no implementation required
+ }
+
+// ---------------------------------------------------------------------------
+// All lock state observers are created here.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::ConstructL( )
+ {
+ INFO( "CLockAppStateControl::ConstructL started" );
+
+ // creates observer list
+ BaseConstructL( );
+
+ // localized resources are loaded
+ TFileName resourceFile;
+ resourceFile.Append( KRESOURCEFILE );
+ BaflUtils::NearestLanguageFile( iEikonEnv->FsSession(), resourceFile );
+ iResourceFileOffset = iEikonEnv->AddResourceFileL(resourceFile);
+
+ // fetch power key configuration from feature manager
+ FeatureManager::InitializeLibL( );
+ iFeatureNoPowerkey = FeatureManager::FeatureSupported( KFeatureIdNoPowerkey );
+ FeatureManager::UnInitializeLib( );
+
+ // allow autoforwarding for the application (stacked bringforwards)
+ iEikonEnv->SetAutoForwarding( ETrue );
+
+ CLockAppKeyCaptureController::InitL( iEikonEnv->RootWin() );
+
+ // Create second windowgroup for visibility gate
+ CreateVisibilityGateWgL( );
+
+ INFO_1( "CLockAppStateControl - EventGate WgID = %d", iWGEventGate.WindowGroupId() );
+ INFO_1( "CLockAppStateControl - VisibilityGate WgID = %d", iWGVisibilityGate.WindowGroupId() );
+
+ //
+ // Construct Controls
+ //
+ iIdle = CLockAppIdleControl::NewL( *this );
+ AddObserverL( iIdle ); // ownership is transfered
+
+ iCurrentControl = iIdle;
+ iCurrentControl->HandleActivateEventL( iEnvState );
+
+ iKeyguard = CLockAppKeyguardControl::NewL( *this );
+ AddObserverL( iKeyguard ); // ownership is transfered
+
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ iDevicelock = CLockAppDevicelockControl::NewL( *this, iWGVisibilityGate );
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ iDevicelock->ConnectToPhoneL( iWGVisibilityGate );
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ AddObserverL( iDevicelock ); // ownership is transfered
+
+ // Emergency support
+ iLockEcsDetector = CLockAppEcsDetector::NewL( );
+ AddObserverL( iLockEcsDetector ); // ownership is transfered
+
+ // Lock state publisher
+ CLockAppStatePublisher* lockPublisher = CLockAppStatePublisher::NewL( );
+ AddObserverL( lockPublisher ); // ownership is transfered
+
+ // PubSub observers
+ iPSScreenSaverObserver = CLockAppPubSubObserver::NewL( this, KPSUidScreenSaver, KScreenSaverOn );
+ iPSTelephonyObserver = CLockAppPubSubObserver::NewL( this, KPSUidCtsyCallInformation, KCTsyCallState );
+ iPSGripObserver = CLockAppPubSubObserver::NewL( this, KPSUidHWRM, KHWRMGripStatus );
+
+ iPSFPSObserver = CLockAppPubSubObserver::NewL( this, KUidFpsCategory, KFpsAuthenticationKey );
+
+ // Call bubble
+ iIncallBubble = CAknIncallBubble::NewL( );
+
+ ActivateL( );
+
+ INFO( "CLockAppStateControl::ConstructL completed" );
+ }
+
+// ---------------------------------------------------------------------------
+// Create visibility gate window group
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::CreateVisibilityGateWgL( )
+ {
+ INFO( "CLockAppStateControl - CreateVisibilityGateL" );
+
+ iWGVisibilityGate = RWindowGroup( iCoeEnv->WsSession( ) );
+ User::LeaveIfError( iWGVisibilityGate.Construct( (TUint32) &iWGVisibilityGate ) );
+
+ /* hide this window group from the app switcher */
+ iWGVisibilityGate.SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );
+ iWGVisibilityGate.EnableReceiptOfFocus( EFalse );
+
+ /*CApaWindowGroupName* wn = CApaWindowGroupName::NewLC( ws );
+ wn->SetHidden( ETrue );
+ wn->SetWindowGroupName( iWGVisibilityGate );
+ CleanupStack::PopAndDestroy( wn );*/
+ }
+
+// ---------------------------------------------------------------------------
+// This method should be called to enable keyguard.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::EnableKeyguardL( TBool aWithNote )
+ {
+ INFO_1( "CLockAppStateControl::EnableKeyguardL aWithNote= %d", aWithNote );
+ TInt err = CheckIfLegal( ELockAppEnableKeyguard );
+ if ( err == KErrNone && !iKeyguard->ActivationAllowedL( ) )
+ {
+ err = KErrPermissionDenied;
+ }
+ if ( err == KErrNone )
+ {
+ PostStatusChangeL( EKeyguardActive );
+ __ASSERT_DEBUG( iLockStatus == EKeyguardActive, DoPanic(ELockIllegalState));
+ INFO( "CLockAppStateControl - Keyguard Enabled" );
+ if ( aWithNote )
+ {
+ iKeyguard->DisplayKeysLockedNote( );
+ }
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// This method should be called to disable keyguard.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::DisableKeyguardL( TBool aWithNote )
+ {
+ INFO_1( "CLockAppStateControl::DisableKeyguardL aWithNote= %d", aWithNote );
+ TInt err = CheckIfLegal( ELockAppDisableKeyguard );
+ if ( err == KErrNone && !iKeyguard->DeActivationAllowedL( ) )
+ {
+ err = KErrPermissionDenied;
+ }
+ if ( err == KErrNone )
+ {
+ PostStatusChangeL( ELockNotActive );
+ __ASSERT_DEBUG( iLockStatus == ELockNotActive, DoPanic(ELockIllegalState));
+ INFO( "CLockAppStateControl - Keyguard Disabled" );
+ if ( aWithNote )
+ {
+ iKeyguard->DisplayKeysActiveNote( );
+ }
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// This method should be called to enable device lock.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::EnableDevicelockL( TDevicelockReason aReason )
+ {
+ INFO_1( "CLockAppStateControl::EnableDevicelockL aReason= %d", aReason );
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ TInt err = CheckIfLegal( ELockAppEnableDevicelock );
+ if ( err == KErrNone && !iDevicelock->ActivationAllowedL( aReason ) )
+ {
+ err = KErrPermissionDenied;
+ }
+ if ( err == KErrNone )
+ {
+ PostStatusChangeL( EDevicelockActive );
+ __ASSERT_DEBUG( iLockStatus == EDevicelockActive, DoPanic(ELockIllegalState));
+ iDevicelock->SetLockingReason( aReason );
+ INFO( "CLockAppStateControl - Devicelock Enabled" );
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// This method should be called to disable device lock.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::DisableDevicelockL( )
+ {
+ INFO_1( "CLockAppStateControl::DisableDevicelockL 1= %d", 1 );
+ TInt err = CheckIfLegal( ELockAppDisableDevicelock );
+ if ( err == KErrNone && !iDevicelock->DeActivationAllowedL( ) )
+ {
+ err = KErrPermissionDenied;
+ }
+ if ( err == KErrNone )
+ {
+ PostStatusChangeL( ELockNotActive );
+ __ASSERT_DEBUG( iLockStatus == ELockNotActive, DoPanic(ELockIllegalState));
+ INFO( "CLockAppStateControl - Devicelock Disabled" );
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// Checks if offer keyguard is allowed and if it is, offers to lock keyguard.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::OfferKeyguard( )
+ {
+ INFO_1( "CLockAppStateControl::OfferKeyguard 1= %d", 1 );
+ TInt err = CheckIfLegal( ELockAppOfferKeyguard );
+ if ( err == KErrNone )
+ {
+ __ASSERT_DEBUG( iLockStatus == ELockNotActive, DoPanic(ELockIllegalState));
+ INFO( "CLockAppStateControl - OfferKeyguard" );
+ iIdle->OfferKeyLock( );
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// Shows keys locked note if keyguard is enabled.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::ShowKeysLockedNote( )
+ {
+ INFO_1( "CLockAppStateControl::ShowKeysLockedNote 1= %d", 1 );
+ TInt err = CheckIfLegal( ELockAppShowKeysLockedNote );
+ if ( err == KErrNone )
+ {
+ __ASSERT_DEBUG( iLockStatus == EKeyguardActive, DoPanic(ELockIllegalState));
+ INFO( "CLockAppStateControl - ShowKeysLockedNote" );
+ iKeyguard->DisplayLockedNote( );
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+// A method for returning the lock status.
+// ---------------------------------------------------------------------------
+TLockStatus CLockAppStateControl::LockStatus( ) const
+ {
+ INFO_1( "CLockAppStateControl::LockStatus iLockStatus= %d", iLockStatus );
+ return iLockStatus;
+ }
+
+// ---------------------------------------------------------------------------
+// A method for returning the environment status bitmask.
+// ---------------------------------------------------------------------------
+TUint CLockAppStateControl::EnvironmentStatus( ) const
+ {
+ return iEnvState;
+ }
+
+// ---------------------------------------------------------------------------
+// A method for executing different internal tests.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::ExecuteInternalTest( )
+ {
+#ifdef _DEBUG
+ return iLockEcsDetector->TestEcsNote( );
+#else
+ return KErrNone;
+#endif
+ }
+
+// ---------------------------------------------------------------------------
+// Number of owned UI controls (idle, keyguard, devicelock)
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::CountComponentControls( ) const
+ {
+ return 3;
+ }
+
+// ---------------------------------------------------------------------------
+// Owned UI controls (idle, keyguard, devicelock)
+// ---------------------------------------------------------------------------
+CCoeControl* CLockAppStateControl::ComponentControl( TInt aIndex ) const
+ {
+ RDebug::Printf( "%s %s (%u) aIndex=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aIndex );
+ switch ( aIndex )
+ {
+ case 0:
+ return iIdle;
+ case 1:
+ return iKeyguard;
+ case 2:
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ return iDevicelock;
+ default:
+ return NULL;
+ }
+ }
+
+// ----------------------------------------------------------
+// Handle window-server events
+// ----------------------------------------------------------
+void CLockAppStateControl::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* /*aDestination*/)
+ {
+ TInt type = aEvent.Type( );
+ RDebug::Printf( "%s %s (%u) type=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, type );
+ switch ( type )
+ {
+ case KAknFullOrPartialForegroundLost: // partial or full fg lost
+ case KAknFullOrPartialForegroundGained: // partial or full fg gained
+ {
+ RDebug::Printf( "%s %s (%u) type=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, type );
+ RWsSession& ws = iCoeEnv->WsSession( );
+ TFileName windowName;
+ TInt fwgid = ws.GetFocusWindowGroup( );
+ ws.GetWindowGroupNameFromIdentifier( fwgid, windowName );
+ INFO_3( "CLockAppStateControl::HandleWsEventL type: %d - FocusWg: %d %S", type, fwgid, &windowName);
+ }
+ break;
+ case EEventKeyUp:
+ case EEventKey:
+ case EEventKeyDown:
+ {
+ RDebug::Printf( "%s %s (%u) EEventKey*=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, EEventKeyDown );
+ TKeyEvent* aKeyEvent = aEvent.Key();
+ TKeyResponse response = OfferKeyEventL( *aKeyEvent, (TEventCode)type );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// From @c CAknAppUiBase. Overriden the parent method, because otherwise
+// the main lock state control would not receive the call, because is is not
+// window-owning control (=without window->not visible). The call is needed
+// because the main state control owns window-owning child controls.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::HandleResourceChange( TInt aType )
+ {
+ // these would not normally get handleresource call since they do not own window
+ RDebug::Printf( "%s %s (%u) aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aType );
+ if(iIdle)
+ iIdle->HandleResourceChange( aType );
+ if(iKeyguard)
+ iKeyguard->HandleResourceChange( aType );
+ if(iDevicelock)
+ iDevicelock->HandleResourceChange( aType );
+ // call parent
+ CCoeControl::HandleResourceChange( aType );
+ }
+
+// ---------------------------------------------------------------------------
+// Update the environment state variable with the event.
+// ---------------------------------------------------------------------------
+TBool CLockAppStateControl::HandleEnvironmentChange( TUint aEventMask, TBool aEnable )
+ {
+ // check if there will be a change
+
+ if ( IsBitFieldSet( iEnvState, aEventMask ) != aEnable )
+ {
+ // set the bit-field
+ SetBitField( iEnvState, aEventMask, aEnable );
+ // notify current control
+ __ASSERT_DEBUG( iCurrentControl, DoPanic(ELockIllegalState));
+ iCurrentControl->HandleEnvironmentChange( iEnvState, aEventMask );
+ // return true because the environment changed
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// Handle all Central Repository observer callbacks.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::HandleCenRepNotify(TUid aCenRepUid, TUint32 aKeyId, TInt aValue )
+ {
+ RDebug::Printf( "%s %s (%u) ???? Nothing done for aKeyId=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyId );
+
+ INFO_3( "CLockAppStateControl::HandleCenRepNotify %d %d = %d", aCenRepUid.iUid, aKeyId, aValue );
+ }
+
+// ---------------------------------------------------------------------------
+// Handle all Publish & Subscribe observer callbacks.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::HandlePubSubNotify(TUid aPubSubUid, TUint aKeyId, TInt aValue )
+ {
+ INFO_3( "CLockAppStateControl::HandlePubSubNotify %x %x = %d", aPubSubUid.iUid, aKeyId, aValue );
+ INFO_3( "CLockAppStateControl::HandlePubSubNotify KPSUidScreenSaver=%x KPSUidCtsyCallInformation=%x KPSUidAiInformation=%x", KPSUidScreenSaver, KPSUidCtsyCallInformation, KPSUidAiInformation );
+ INFO_3( "CLockAppStateControl::HandlePubSubNotify KPSUidHWRM=%x KHWRMGripStatus=%x KPSUidAiInformation=%x", KPSUidHWRM, KHWRMGripStatus, KPSUidAiInformation );
+ if ( aPubSubUid == KPSUidScreenSaver )
+ {
+ switch ( aKeyId )
+ {
+ case KScreenSaverOn:
+ {
+ INFO_1("CLockAppStateControl::ScreenSaver - %d", (aValue > 0));
+ HandleEnvironmentChange( KLockAppEnvScreenSaverOn, (aValue > 0) );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else if ( aPubSubUid == KPSUidCtsyCallInformation )
+ {
+ switch ( aKeyId )
+ {
+ case KCTsyCallState:
+ {
+ PrintCallState( aValue );
+ HandleEnvironmentChange( KLockAppEnvPhonecallOngoing, (aValue > EPSCTsyCallStateNone) );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else if ( aPubSubUid == KPSUidAiInformation ) // ActiveIdle
+ {
+ switch ( aKeyId )
+ {
+ case KActiveIdleState:
+ {
+ INFO_1("CLockAppStateControl::ActiveIdle - %d", (aValue == EPSAiForeground));
+ HandleEnvironmentChange( KLockAppEnvIdleOnForeground, (aValue == EPSAiForeground) );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else if ( aPubSubUid == KPSUidHWRM )
+ {
+ switch ( aKeyId )
+ {
+ case KHWRMGripStatus:
+ {
+ INFO_1("CLockAppStateControl::Grip - %d", aValue );
+ HandleEnvironmentChange( KLockAppEnvGrip, (aValue == EPSHWRMGripOpen) );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else if ( aPubSubUid == KUidFpsCategory )
+ {
+ switch ( aKeyId )
+ {
+ case KFpsAuthenticationKey:
+ {
+ INFO_1("CLockAppStateControl::Grip - %d", aValue );
+ #define EAuthenticationSuccess 1
+ HandleEnvironmentChange( KLockAppEnvFPS, (aValue == EAuthenticationSuccess) );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// All keyevents should go trough here.
+// ---------------------------------------------------------------------------
+TKeyResponse CLockAppStateControl::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )
+ {
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ RDebug::Printf( "%s %s (%u) aKeyEvent.iCode=%x aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyEvent.iCode, aType );
+ TKeyResponse keyResponse = PreCheckKeyEvents( aKeyEvent, aType );
+ if ( keyResponse == EKeyWasNotConsumed )
+ {
+ if ( aKeyEvent.iRepeats == 0 )
+ {
+ // handle only without the repeats
+ INFO_3("KeyEvent %d, %d, %d", aType, aKeyEvent.iCode, aKeyEvent.iScanCode );
+ __ASSERT_DEBUG( iCurrentControl, DoPanic(ELockIllegalState));
+ keyResponse = iCurrentControl->OfferKeyEventL( aKeyEvent, aType );
+ }
+ else
+ {
+ // set consumed which are repeated
+ keyResponse = EKeyWasConsumed;
+ }
+ }
+
+ return keyResponse;
+ }
+
+// ---------------------------------------------------------------------------
+// From @c CLockAppObserverList. The main state control is the first
+// to handle the lock state changes, locks/unlocks the phone depending
+// on the state change.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::HandleLockStatusChangedL( TLockStatus aLockStatus )
+ {
+ __ASSERT_DEBUG( iCurrentControl, DoPanic(ELockIllegalState));
+ INFO_1("CLockAppStateControl::HandleLockStatusChangedL - %d", aLockStatus);
+ iCurrentControl->HandleDeActivateEventL( iEnvState );
+
+ switch ( aLockStatus )
+ {
+ case ELockNotActive:
+ {
+ iCurrentControl = iIdle;
+ MuteSounds( EFalse );
+ BringForward( EFalse );
+ }
+ break;
+ case EKeyguardActive:
+ {
+ iCurrentControl = iKeyguard;
+ MuteSounds( ETrue );
+ BringForward( ETrue );
+ }
+ break;
+ case EDevicelockActive:
+ {
+ RDebug::Printf( "%s %s (%u) iDevicelock=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iDevicelock );
+ iCurrentControl = iDevicelock;
+ MuteSounds( ETrue );
+ BringForward( ETrue );
+ }
+ break;
+ default:
+ INFO_1("CLockAppStateControl::HandleLockStatusChangedL - ???? aLockStatus=%d", aLockStatus);
+ DoPanic( ELockUnknownValue );
+ break;
+ }
+
+ __ASSERT_DEBUG( iCurrentControl, DoPanic(ELockIllegalState));
+ iCurrentControl->HandleActivateEventL( iEnvState );
+
+ // finally we update the value (only place were changing the status is allowed)
+ iLockStatus = aLockStatus;
+ }
+
+// ---------------------------------------------------------------------------
+// Check if requested transition is valid.
+// ---------------------------------------------------------------------------
+TInt CLockAppStateControl::CheckIfLegal( TLockAppMessageReason aReason )
+ {
+ INFO_1("CLockAppStateControl::CheckIfLegal aReason=%d", aReason);
+ INFO_1("CLockAppStateControl::CheckIfLegal iLockStatus=%d", iLockStatus);
+ switch ( aReason )
+ {
+ case ELockAppEnableKeyguard:
+ {
+ RDebug::Printf( "%s %s (%u) ELockAppEnableKeyguard iLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ if ( !CKeyLockPolicyApi::KeyguardAllowed() )
+ return KErrPermissionDenied;
+ else
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrAlreadyExists;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ case ELockAppDisableKeyguard:
+ {
+ RDebug::Printf( "%s %s (%u) ELockAppDisableKeyguard iLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrAlreadyExists;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ case ELockAppEnableDevicelock:
+ {
+ RDebug::Printf( "%s %s (%u) ELockAppEnableDevicelock iLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrAlreadyExists;
+ }
+ }
+ break;
+ case ELockAppDisableDevicelock:
+ {
+ RDebug::Printf( "%s %s (%u) ELockAppDisableDevicelock iLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrAlreadyExists;
+ case EKeyguardActive:
+ return KErrPermissionDenied;
+ case EDevicelockActive:
+ return KErrNone;
+ }
+ }
+ break;
+ case ELockAppOfferKeyguard:
+ {
+ RDebug::Printf( "%s %s (%u) ELockAppOfferKeyguard iLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrNone;
+ case EKeyguardActive:
+ return KErrPermissionDenied;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ case ELockAppShowKeysLockedNote:
+ {
+ RDebug::Printf( "%s %s (%u) ELockAppShowKeysLockedNote iLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus );
+ switch ( iLockStatus )
+ {
+ case ELockNotActive:
+ return KErrPermissionDenied;
+ case EKeyguardActive:
+ return KErrNone;
+ case EDevicelockActive:
+ return KErrPermissionDenied;
+ }
+ }
+ break;
+ }
+ return KErrPermissionDenied;
+ }
+
+// ---------------------------------------------------------------------------
+// Prescreen key events for special cases before giving them to child controls
+// ---------------------------------------------------------------------------
+TKeyResponse CLockAppStateControl::PreCheckKeyEvents(const TKeyEvent& aKeyEvent, TEventCode aType )
+ {
+ RDebug::Printf( "%s %s (%u) aKeyEvent.iCode=%x aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyEvent.iCode, aType );
+ TKeyResponse keyResponse = EKeyWasNotConsumed;
+ // power key always turns the lights on
+ CheckForPowerKeyLights( aKeyEvent, aType );
+ if ( iLockEcsDetector->EcsNoteOnScreen( ) )
+ {
+ // the key events are fully handled by the emergency
+ // detector when emergency note is shown
+ keyResponse = EKeyWasConsumed;
+ }
+ else
+ {
+ if ( CheckForPhoneKeys( aKeyEvent, aType ) )
+ {
+ keyResponse = EKeyWasConsumed;
+ }
+ else if ( aKeyEvent.iCode == EKeyLeftShift || aKeyEvent.iCode == EKeyRightShift )
+ {
+ // eat these modifier events as they just cause problems elsewhere
+ keyResponse = EKeyWasConsumed;
+ }
+ }
+ return keyResponse;
+ }
+
+// ---------------------------------------------------------------------------
+// Checks if power key has been pressed and inform the sysap accordingly.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::CheckForPowerKeyLights( const TKeyEvent& aKeyEvent, TEventCode aType )
+ {
+ // only handle power key when keys are locked
+ RDebug::Printf( "%s %s (%u) aKeyEvent.iCode=%x aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyEvent.iCode, aType );
+ RDebug::Printf( "%s %s (%u) iLockStatus=%x ELockNotActive=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus, ELockNotActive );
+ if ( iLockStatus != ELockNotActive )
+ {
+ RDebug::Printf( "%s %s (%u) iFeatureNoPowerkey=%x EStdKeyDevice2=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iFeatureNoPowerkey, EStdKeyDevice2 );
+ if ( (aType == EEventKey && aKeyEvent.iRepeats == 0) || (aType == EEventKeyDown && aKeyEvent.iScanCode == EStdKeyDevice2) ) // Power key
+ {
+ // If power key pressed, tell SysAp about if
+ if ( (aKeyEvent.iScanCode == EStdKeyDevice2 && aType == EEventKeyDown) || (iFeatureNoPowerkey && aKeyEvent.iCode == EKeyNo) )
+ {
+ // normal power key event
+ RDebug::Printf( "%s %s (%u) EEikKeyLockPowerKeyPressed=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iFeatureNoPowerkey );
+ SendMessageToSysAp( EEikKeyLockPowerKeyPressed );
+ if ( iFeatureNoPowerkey )
+ {
+ RDebug::Printf( "%s %s (%u) EEikKeyLockLightsOnRequest=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, EEikKeyLockLightsOnRequest );
+ // end key as power key needs additional info (ugly solution)
+ SendMessageToSysAp( EEikKeyLockLightsOnRequest );
+ }
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Checks if green or red key has been pressed and forward it to phone
+// in case there is a phone call ongoing.
+// ---------------------------------------------------------------------------
+TBool CLockAppStateControl::CheckForPhoneKeys( const TKeyEvent& aKeyEvent, TEventCode aType )
+ {
+ RDebug::Printf( "%s %s (%u) aKeyEvent.iCode=%x aType=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aKeyEvent.iCode, aType );
+#ifndef RD_GLOBALWG_PRIORITY_CHANGE
+ // only handle phone keys when locked and phonecall ongoing
+ RDebug::Printf( "%s %s (%u) iLockStatus=%x ELockNotActive=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, iLockStatus, ELockNotActive );
+ if ( iLockStatus != ELockNotActive )
+ {
+ if ( aKeyEvent.iScanCode == EStdKeyYes || aKeyEvent.iScanCode == EStdKeyNo )
+ {
+ if ( IsBitFieldSet( iEnvState, KLockAppEnvPhonecallOngoing ) ) // TODO what about video-call
+ {
+ // send Green and Red keys to phoneapp's windowgroup
+ INFO( "CLockAppStateControl::CheckForPhoneKeys - SendKeyToPhoneApp");
+ SendKeyToPhoneApp( aKeyEvent, aType );
+ return ETrue;
+ }
+ }
+ }
+#endif // !RD_GLOBALWG_PRIORITY_CHANGE
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// Brings foreground/background the root window.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::BringForward(TBool aForeground )
+ {
+ RDebug::Printf( "%s %s (%u) aForeground=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aForeground );
+ if ( aForeground )
+ {
+ INFO_4( "CLockAppStateControl::BringForward(1) STA - EvWG(%d,%d) ViWG(%d,%d)",
+ iWGEventGate.OrdinalPosition(), iWGEventGate.OrdinalPriority(),
+ iWGVisibilityGate.OrdinalPosition(), iWGVisibilityGate.OrdinalPriority());
+ // not sure if these cause flush in WindowServer
+ iWGVisibilityGate.SetOrdinalPosition( 0, ECoeWinPriorityAlwaysAtFront + KGlobalWindowPriority_LockVisibilityGate );
+ iWGEventGate.SetOrdinalPosition( 0, ECoeWinPriorityAlwaysAtFront + KGlobalWindowPriority_LockVisibilityGate );
+ iEikonEnv->BringForwards( ETrue, ECoeWinPriorityAlwaysAtFront + KGlobalWindowPriority_KeyLock );
+ /*if ( iIncallBubble )
+ {
+ iIncallBubble->SetIncallBubbleAllowedInIdleL( ETrue );
+ }*/
+ }
+ else
+ {
+ INFO_4( "CLockAppStateControl::BringForward(0) STA - EvWG(%d,%d) ViWG(%d,%d)",
+ iWGEventGate.OrdinalPosition(), iWGEventGate.OrdinalPriority(),
+ iWGVisibilityGate.OrdinalPosition(), iWGVisibilityGate.OrdinalPriority());
+
+ // not sure if these cause flush in WindowServer
+ iWGVisibilityGate.SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );
+ iWGEventGate.SetOrdinalPosition( 0, ECoeWinPriorityNeverAtFront );
+ iEikonEnv->BringForwards( EFalse );
+ /*if ( iIncallBubble )
+ {
+ iIncallBubble->SetIncallBubbleAllowedInIdleL( EFalse );
+ }*/
+ }
+
+ INFO_4( "CLockAppStateControl::BringForward END - EvWG(%d,%d) ViWG(%d,%d)",
+ iWGEventGate.OrdinalPosition(), iWGEventGate.OrdinalPriority(),
+ iWGVisibilityGate.OrdinalPosition(), iWGVisibilityGate.OrdinalPriority());
+ }
+
+// ---------------------------------------------------------------------------
+// Mute key sounds when phone is locked.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::MuteSounds(TBool aMuteSounds )
+ {
+ RDebug::Printf( "%s %s (%u) aMuteSounds=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aMuteSounds );
+ if ( iSoundsMuted != aMuteSounds )
+ {
+ if ( aMuteSounds )
+ {
+ TRAPD(err, iAvkonAppUiBase->KeySounds()->PushContextL(R_AVKON_SILENT_SKEY_LIST))
+ if ( !err )
+ {
+ iAvkonAppUiBase->KeySounds()->BringToForeground();
+ iAvkonAppUiBase->KeySounds()->LockContext();
+ iSoundsMuted = ETrue;
+ }
+ }
+ else
+ {
+ iAvkonAppUiBase->KeySounds()->ReleaseContext();
+ iAvkonAppUiBase->KeySounds()->PopContext();
+ iSoundsMuted = EFalse;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Print out call state.
+// ---------------------------------------------------------------------------
+void CLockAppStateControl::PrintCallState( TInt aValue )
+ {
+ RDebug::Printf( "%s %s (%u) aValue=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, aValue );
+ switch ( aValue )
+ {
+ case EPSCTsyCallStateUninitialized:
+ INFO("CLockAppStateControl::PrintCallState - Uninitialized")
+ break;
+ case EPSCTsyCallStateNone:
+ INFO("CLockAppStateControl::PrintCallState - None")
+ break;
+ case EPSCTsyCallStateAlerting:
+ INFO("CLockAppStateControl::PrintCallState - Alerting")
+ break;
+ case EPSCTsyCallStateRinging:
+ INFO("CLockAppStateControl::PrintCallState - Ringing")
+ break;
+ case EPSCTsyCallStateDialling:
+ INFO("CLockAppStateControl::PrintCallState - Dialling")
+ break;
+ case EPSCTsyCallStateAnswering:
+ INFO("CLockAppStateControl::PrintCallState - Answering")
+ break;
+ case EPSCTsyCallStateDisconnecting:
+ INFO("CLockAppStateControl::PrintCallState - Disconnecting")
+ break;
+ case EPSCTsyCallStateConnected:
+ INFO("CLockAppStateControl::PrintCallState - Connected")
+ break;
+ case EPSCTsyCallStateHold:
+ INFO("CLockAppStateControl::PrintCallState - Hold")
+ break;
+ default:
+ break;
+ }
+ }
+
+// END OF FILE