diff -r 951aeeb3da43 -r eea20ed08f4b coreapplicationuis/SysAp/Src/SysApAppUi.cpp --- a/coreapplicationuis/SysAp/Src/SysApAppUi.cpp Fri Jun 11 13:48:03 2010 +0300 +++ b/coreapplicationuis/SysAp/Src/SysApAppUi.cpp Tue Jun 29 10:40:11 2010 +0300 @@ -14,178 +14,72 @@ * Description: CSysApAppUi implementation. * */ - - // INCLUDES -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - +#include +#include "sysapappui.h" +#include "coreapplicationuisprivatepskeys.h" +#include +//#include +#include +#include +#include +#include +#include +#include #include -#include - -#include -#include "coreapplicationuisprivatepskeys.h" -#include -#include -#include +#include +#include +//#include +#include +//#include +#include -#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS - #include -#else - #include - #include - #include -#endif //SYMBIAN_ENABLE_SPLIT_HEADERS - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include "SysApSimChanged.h" - -#include -#include "SysApLightsController.h" - +//#include "SysApWsClient.h" +#include "SysApFeatureManager.h" +#include "SysApNspsHandler.h" #include "SysApPubSubObserver.h" -#include "SysApProfileObserver.h" - +#include "sysapdefaultkeyhandler.h" +#include "SysApStartupController.h" +#include "MSysApOfflineModeController.h" +#include "SysApCenRepController.h" #include "sysapcenreplightsettingsobserver.h" #include "SysApCenRepLogsObserver.h" #include "SysApCenRepBTObserver.h" #include "SysApCenRepHacSettingObserver.h" -#include "SysApCenRepController.h" -#include "coreapplicationuisprivatecrkeys.h" -#include "coreapplicationuisprivatepskeys.h" -#include - -#include "SysApStartupController.h" -#include "SysApConnectionMonitorObserver.h" -#include "SysApPowerKeyMenuObserver.h" -#include "SysApSsSettingsObserver.h" -#include "SysApAppUi.h" +#include "sysapaudioroutingobserver.h" +#include "sysapbatteryinfocontroller.h" +#include "SysApSimChanged.h" +#include "MSysApBtSapController.h" +#include "MSysApBtController.h" +#include "MSysApUsbIndicator.h" +//#include +//#include +//#include +#include "sysapkeymanagement.h" #include "SysApShutdownImage.h" -#include "SysApEtelConnector.h" - -#include "SysApApp.h" -#include "SysApMsgSimMemLowQuery.h" -#include "SysApNspsHandler.h" -#include "SysApWaitNote.h" -#include "SysApConfirmationQuery.h" -#include "SysApFeatureManager.h" -#include "SysApSubscriber.h" -#include "MSysApOfflineModeController.h" -#include "MSysApBtController.h" -#include "MSysApBtSapController.h" -#include "MSysApLocationPrivacyIndicator.h" -#include "MSysApUsbIndicator.h" - -#include - -#include "SysApShutdownAnimation.h" - -//#include -//#include -//#include -//#include "sysapcenrepfmtxobserver.h" - #include "SysApKeySndHandler.h" -#include // KIrdaPropertyCategory // KIrdaStatus - -#include - -// POC launching -#include -#include - -#include // KUidPhonePwr - -#include // WLan indicator - -#include -#include "sysapkeymanagement.h" - -#include "SysApMediatorObserver.h" - -#include -#include "aknSDData.h" - -#include -#include - -#include "sysapdefaultkeyhandler.h" -#include "sysapaudioroutingobserver.h" -#include "sysapcenrepcallforwardingobserver.h" -#include "sysapcenrepmsgwaitingobserver.h" - -#ifdef RD_MULTIPLE_DRIVE - #include "sysapdrivelist.h" - #include "sysapdriveunlockhandler.h" - #include "sysapdriveejecthandler.h" -#endif // RD_MULTIPLE_DRIVE +#include +#include +#include +#include -#include "sysappsmcontroller.h" -#include "sysapbatteryinfocontroller.h" - -#include - -#include // USB transfer modes -#include -#include -#include -#include - -// CONSTANTS -const TInt KPowerKeyMenuSelectionCancelled( -1 ); -const TInt KPowerKeyMenuSelectionSwitchOff( 0 ); +class CHbSymbianVariant; const TInt KModifierMask( 0 ); -const TInt KDelayBeforeShuttingDownInAlarmAndChargingStates( 500000 ); -const TInt KDelayBeforeShowingGprsSuspendedNote( 500000 ); -const TInt KDelayBeforeNextScanningRound( 1000000 ); -const TInt KActiveProfile( 0 ); //The value of ActiveProfile for accessory default profile selection in GS/SD. -const TInt KProfileListInitialIndex( 0 ); -const TInt KMaxProfileNameLength( 64 ); -const TInt KTimeToShowShutdownNote( 2000000 ); //2 seconds time for Goodbye note to show before being shutdown -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION -const TInt KCoefficientToMakeMicroToMilliSeconds = 1000; -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - -/* ENABLE ANIMATION: Add id of background image. - Example: const TInt KBackgroundImageID = EMbmSysapQgn_graf_startup_bg; - If there is no image defined, clear screen is used.*/ -const TInt KBackgroundImageID = 0; -#ifndef RD_MULTIPLE_DRIVE -const TInt32 KAutolockAppUid = 0x100059B5; -const TInt KFileManagerAppUid = 0x101F84EB; -#endif // RD_MULTIPLE_DRIVE -const TInt KCoefficientKhzToMhz = 1000; -const TInt KDecimalsInMhzFrequency = 2; - _LIT_SECURITY_POLICY_PASS(KAlwaysPassPolicy); _LIT_SECURITY_POLICY_C1(KWriteDeviceDataPolicy, ECapabilityWriteDeviceData); +const TInt KDelayBeforeNextScanningRound( 1000000 ); +/* +_LIT(KPsmPlugin,"com.nokia.hb.powersavemodeplugin/1.0"); +_LIT(KPsm,"PSM"); +_LIT(KCharging,"Charging"); +_LIT(KPsmlocalisationfile, "powermanagement_"); +_LIT(KtsfilePath, "z:/resource/qt/translations/"); +_LIT(KlowbatteryIcon,"qtg_small_bt_low_battery.svg"); +_LIT(KbatteryFullIcon,"qtg_status_battery.svg"); + +*/ // ============================ MEMBER FUNCTIONS ============================== @@ -193,61 +87,25 @@ // CSysApAppUi::CSysApAppUi() // ---------------------------------------------------------------------------- -CSysApAppUi::CSysApAppUi() : - iSysApCenRepLogsObserver( NULL ), - iSysApCenRepHacSettingObserver( NULL ), - iSysApPowerKeyMenuObserver( NULL ), - iSysApShutdownImage( NULL ), - iSysApConfirmationQuery( NULL ), - iSysApConfirmationQueryForRestart( NULL ), - iSignalNotify( NULL ), -#ifndef RD_MULTIPLE_DRIVE - iMemoryCardDialog( 0 ), -#endif // RD_MULTIPLE_DRIVE - iProfileNote( NULL ), - iProfileNoteId( 0 ), - iPowerKeyPopupMenuActive( EFalse ), - iDisablePowerkeyMenu( EFalse ), - iDeviceLockEnabled( EFalse ), - iKeyLockEnabled( EFalse ), - iShowkeypadActivatedNoteAfterSoftReject( EFalse ), - iEmergencyCallActive( EFalse ), - iSimChangedDone( EFalse ), - iResourcesFreed( EFalse ), -#ifndef RD_MULTIPLE_DRIVE - iHideFirstBeep( ETrue ), -#endif // RD_MULTIPLE_DRIVE - iShutdownStarted( EFalse ), - iIgnoreAccessorySpecificProfileChanges( ETrue ), - iAccessoryJustConnected( EFalse ), - iHandleNextProfileEvent( ETrue ), - iActivateBt( EFalse ), - iDeactivateBt( EFalse ), - iGprsActivated( EFalse ), - iGprsSuspended( EFalse ), - iCallActivated( EFalse ), - iGprsSuspendedNoteShown( EFalse ), - iMMCEjectUsed( EFalse ), -#ifndef RD_MULTIPLE_DRIVE - iMMCPowerMenuEjectUsed( EFalse ), - iMMCInserted( EFalse ), -#endif // RD_MULTIPLE_DRIVE - iTimer( NULL ), - iSapTimer( NULL ), -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - iAnimTimer( NULL ), -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - iSysApTimer( NULL ), -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - iAnimationShowingTime( 0 ), -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - iShutdownContinued( EFalse ), - iSysApAudioRoutingObserver( NULL ), - iSysApCenRepCallForwardingObserver( NULL ), - iSysApCenRepMsgWaitingObserver( NULL ), - iKeyBoardRepeatCount(-1) - { - TRACES( RDebug::Print( _L("CSysApAppUi::CSysApAppUi()") ) ); +CSysApAppUi::CSysApAppUi() + :iSysApShutdownImage(NULL), + iPowerMenuDialog(NULL), + iDeviceLockEnabled(EFalse), + iKeyLockEnabled(EFalse), + iPowerKeyPopupMenuActive(EFalse), + iResourcesFreed (EFalse), + iShutdownStarted (EFalse), + iSysApAudioRoutingObserver (NULL), + iSysApBatteryInfoController (NULL), + iSysApPsmController(NULL), + iSapTimer (NULL), + iSysApCenRepLogsObserver (NULL), + iSysApUsbIndicatorController(NULL), + iKeyguardController (NULL), + iKeyLockOnBeforeCall (EFalse), + iCheckLongPowerKeyEvent (EFalse) + { + TRACES( RDebug::Print( _L("CSysApAppUi::CSysApAppUi()") ) ); } // ---------------------------------------------------------------------------- @@ -257,61 +115,59 @@ void CSysApAppUi::ConstructL() { TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: START") ) ); - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying BaseConstructL( EAknEnableSkin )") ) ); - BaseConstructL( EAknEnableSkin ); + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying BaseConstructL()") ) ); + BaseConstructL(); TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: BaseConstructL() OK") ) ); - - - /*SysAp is set as system application (Symbian terminology). This means some special privilege compared - to other applications. For example it does not get closed when system is asked to close applications - */ iEikonEnv->SetSystem( ETrue ); iEikonEnv->WsSession().ComputeMode( RWsSession::EPriorityControlDisabled ); - - static_cast(iEikonEnv->EikAppUi())->KeySounds()->PushContextL( R_AVKON_SILENT_SKEY_LIST ); - + RThread().SetProcessPriority( EPriorityForeground ); - - /*SysAp does not have any visible Status pane. An exception will be Charging state - where SysAp shows Status Pane as it is the only running application. - */ + TInt mode; User::LeaveIfError( RProperty::Get( KPSUidStartup, KPSGlobalStartupMode, mode ) ); - - if( mode == EStartupModeCharging || mode == EStartupModeAlarm ) - { - SetStatusPaneLayoutL( - mode == EStartupModeCharging ? ESysApCharging : ESysApAlarm ); - - SetKeyEventFlags( - CAknAppUiBase::EDisableSendKeyShort | - CAknAppUiBase::EDisableSendKeyLong ); - } - else - { - SetStatusPaneLayoutL( ESysApNormal ); - } - + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: KPSGlobalStartupMode = %d"), mode ) ); + + //SysAp needs to capture PowerKey events because it handles all functionality related to that + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CEikApplication::RootWin()") ) ); + RWindowGroup groupWin = iCoeEnv->RootWin(); + User::LeaveIfError ( iCapturedEKeyPowerOff = groupWin.CaptureKey( EKeyPowerOff, KModifierMask, KModifierMask ) ); + User::LeaveIfError ( iCapturedEKeyPowerOffUpAndDowns = groupWin.CaptureKeyUpAndDowns( EStdKeyDevice2, KModifierMask, KModifierMask ) ); + + TRACES ( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApDefaultKeyHandler::NewL()") ) ); + iSysApDefaultKeyHandler = CSysApDefaultKeyHandler::NewL(*this); + + // Define P&S keys "owned" by SysAp + RProperty::Define( KPSUidUikon, KUikMMCInserted, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); + //initially assuming that the memory card is not inserted + RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); + TDriveInfo driveInfo; + TInt driveNumber; + TInt err; + RFs& fileServer = iEikonEnv->FsSession(); + for ( driveNumber = EDriveD; driveNumber < EDriveZ; driveNumber++ ) + { + err = fileServer.Drive(driveInfo,driveNumber); + if(driveNumber == EDriveF && err == KErrNone && driveInfo.iType == EMediaHardDisk && driveInfo.iDriveAtt & KDriveAttRemovable) + { + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: err = %d, driveInfo.iType = %d, driveInfo.iDriveAtt %d, KDriveAttRemovable = %d "),err,driveInfo.iType,driveInfo.iDriveAtt,KDriveAttRemovable) ); + RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 ); + break; // Memory card drive found... + } + } + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApFeatureManager::NewL()") ) ); iSysApFeatureManager = CSysApFeatureManager::NewL(); - + // Setup USB charging detector - iSysApUsbChargerDetector.EnableUsbCharging( - iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) && - iSysApFeatureManager->Supported( KSysApFeatureIdUsbChargingWithoutReminderNotes ) ); - - // Construct notifiers that are used frequently or in OOM situations. - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CAknBatteryNotify::NewL()") ) ); - iBatteryNotify = CAknBatteryNotify::NewL(); - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CAknSignalNotify::NewL()") ) ); - iSignalNotify = CAknSignalNotify::NewL(); - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying new ( ELeave ) CSysApMsgSimMemLowQuery") ) ); - iSysApMsgSimMemLowQuery = new( ELeave ) CSysApMsgSimMemLowQuery( iSysApFeatureManager->CoverDisplaySupported() ); - + iSysApUsbChargerDetector.EnableUsbCharging( + iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) && + iSysApFeatureManager->Supported( KSysApFeatureIdUsbChargingWithoutReminderNotes ) ); + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApPubSubObserver::NewL()") ) ); iSysApPubSubObserver = CSysApPubSubObserver::NewL( *this ); + RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsPoCIndicator, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsPoCIndicator, ECoreAppUIsPocIndicatorUninitialized ); RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsPoCMissedIndicator, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); @@ -324,43 +180,6 @@ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsVideoSharingIndicator, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsVideoSharingIndicator, ECoreAppUIsVideoSharingIndicatorUninitialized ); - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApAccessoryObserver::NewL()") ) ); - iSysApAccessoryObserver = CSysApAccessoryObserver::NewL( *this ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepController::NewL()") ) ); - iSysApCenRepController = CSysApCenRepController::NewL(); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepLightSettingsObserver::NewL") ) ); - iSysApCenRepLightSettingsObserver = CSysApCenRepLightSettingsObserver::NewL( *this ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepBtObserver::NewL") ) ); - iSysApCenRepBtObserver = CSysApCenRepBtObserver::NewL( *this ); - -/* if ( iSysApFeatureManager->FmTxSupported() ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepFmTxObserver::NewL") ) ); - iSysApCenRepFmTxObserver = CSysApCenRepFmTxObserver::NewL( *this ); - } -*/ - // Define P&S keys "owned" by SysAp - RProperty::Define( KPSUidUikon, KUikMMCInserted, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); - //initially assuming that the memory card is not inserted - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - TDriveInfo driveInfo; - TInt driveNumber; - TInt err; - RFs& fileServer = iEikonEnv->FsSession(); - for ( driveNumber = EDriveD; driveNumber < EDriveZ; driveNumber++ ) - { - err = fileServer.Drive(driveInfo,driveNumber); - if(driveNumber == EDriveF && err == KErrNone && driveInfo.iType == EMediaHardDisk && driveInfo.iDriveAtt & KDriveAttRemovable) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: err = %d, driveInfo.iType = %d, driveInfo.iDriveAtt %d, KDriveAttRemovable = %d "),err,driveInfo.iType,driveInfo.iDriveAtt,KDriveAttRemovable) ); - RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 ); - break; // Memory card drive found... - } - } - RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsHideAlarm, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsDisableKeyguard, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsSoftReject, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); @@ -381,717 +200,763 @@ // Initialize P&S keys "owned" by SysAp RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsHideAlarm, ECoreAppUIsHideAlarmUninitialized ); - + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApAccessoryObserver::NewL()") ) ); + iSysApAccessoryObserver = CSysApAccessoryObserver::NewL( *this ); + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepController::NewL()") ) ); + iSysApCenRepController = CSysApCenRepController::NewL(); + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepLightSettingsObserver::NewL") ) ); + iSysApCenRepLightSettingsObserver = CSysApCenRepLightSettingsObserver::NewL( *this ); + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepBtObserver::NewL") ) ); + iSysApCenRepBtObserver = CSysApCenRepBtObserver::NewL( *this ); + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApStartupController::NewL()") ) ); iSysApStartupController = CSysApStartupController::NewL( *this, iSysApFeatureManager->OfflineModeSupported() ); + iActiveProfileBeforeOfflineMode = iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileBeforeOfflineMode ); + + iSysApFeatureManager->FeatureVariationCheckDone(); + // iHbIndicatorSymbian = CHbIndicatorSymbian::NewL(); + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApLightsController::NewL()") ) ); iSysApLightsController = CSysApLightsController::NewL( *this, iSysApCenRepLightSettingsObserver->GetLightsTimeout(), iSysApFeatureManager->CoverDisplaySupported() ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApEtelConnector::NewL()") ) ); - iSysApEtelConnector = CSysApEtelConnector::NewL( *this ); - - //SysAp needs to capture PowerKey events because it handles all functionality related to that - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CEikApplication::RootWin()") ) ); - RWindowGroup groupWin = iCoeEnv->RootWin(); - User::LeaveIfError ( iCapturedEKeyPowerOff = groupWin.CaptureKey( EKeyPowerOff, KModifierMask, KModifierMask ) ); - User::LeaveIfError ( iCapturedEKeyPowerOffUpAndDowns = groupWin.CaptureKeyUpAndDowns( EStdKeyDevice2, KModifierMask, KModifierMask ) ); - - TRACES ( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApDefaultKeyHandler::NewL()") ) ); - iSysApDefaultKeyHandler = CSysApDefaultKeyHandler::NewL( *this ); - - - if ( iSysApFeatureManager->GripNotSupported() ) - { - RProperty::Set( KPSUidHWRM, KHWRMGripStatus, EPSHWRMGripOpen ); - } - -#ifndef RD_MULTIPLE_DRIVE - if ( iSysApFeatureManager->MmcSupported() ) - { - iSysApMMCObserver = CSysApMMCObserver::NewL( this, &iEikonEnv->FsSession(), iSysApFeatureManager->MmcHotSwapSupported() ); - } -#else // RD_MULTIPLE_DRIVE - iSysApDriveList = CSysApDriveList::NewL( iEikonEnv->FsSession() ); - if ( iSysApFeatureManager->MmcSupported() ) - { - iSysApMMCObserver = CSysApMMCObserver::NewL( - iEikonEnv->FsSession(), *iSysApDriveList, *this, iSysApFeatureManager->MmcHotSwapSupported() ); - iSysApDriveUnlockHandler = CSysApDriveUnlockHandler::NewL( - *iSysApDriveList, *this, iSysApFeatureManager->MemoryCardLockSupported() ); - iSysApDriveEjectHandler = CSysApDriveEjectHandler::NewL( - *iSysApDriveList, *this, iEikonEnv->FsSession() ); - } -#endif // RD_MULTIPLE_DRIVE - + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying CreateSysApOfflineModeControllerL()") ) ); + iSysApOfflineModeController = CreateSysApOfflineModeControllerL( *this ); + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying DoInitialSwStateCheckL()") ) ); + iSysApStartupController->DoInitialSwStateCheckL(); + + TRACES( RDebug::Print( _L("CCSysApAppUi::ConstructL trying CSysApCenRepHacSettingObserver::NewL") ) ); + iSysApCenRepHacSettingObserver = CSysApCenRepHacSettingObserver::NewL( *this ); + //Instantiate the KEF plugin manager - //Trap constuction, since Sysap may live without iSysApKeyManagement + //Trap constuction, since Sysap may live without iSysApKeyManagement TRAPD(keyManagementErr, iSysApKeyManagement=CSysApKeyManagement::NewL(CCoeEnv::Static()->RootWin(), *this)); if (keyManagementErr) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : CSysApKeyManagement::NewL returns error=%d"), keyManagementErr ) ); - } - - iSysApFeatureManager->FeatureVariationCheckDone(); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApProfileObserver::NewL()") ) ); - iSysApProfileObserver = CSysApProfileObserver::NewL( *this ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying MProfileEngine* CreateProfileEngineL()") ) ); - iProfileEngine = CreateProfileEngineL( &( iEikonEnv->FsSession() ) ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying CreateSysApOfflineModeControllerL()") ) ); - iSysApOfflineModeController = CreateSysApOfflineModeControllerL( *this ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying DoInitialSwStateCheckL()") ) ); - iSysApStartupController->DoInitialSwStateCheckL(); - - iActiveProfileBeforeOfflineMode = iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileBeforeOfflineMode ); - + { + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : CSysApKeyManagement::NewL returns error=%d"), keyManagementErr ) ); + } + // Initialize animdll for handling side volume keys // (needed before normal mode in case emergency number is dialed from PIN query) iSysApKeySndHandler = CSysApKeySndHandler::NewL(iEikonEnv->WsSession()); - - // Initialize shutdown image (needed by nspshandler) + iKeyguardController = CKeyguardAccessApi::NewL(); TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApShutdownImage::NewL()") ) ); - iSysApShutdownImage = CSysApShutdownImage::NewL(); - + iSysApShutdownImage = CSysApShutdownImage::NewL();//NULL; // + // Initialize nsps handler. Needed for proper lights control during PIN query. TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApNspsHandler::NewL") ) ); iSysApNspsHandler = CSysApNspsHandler::NewL( iEikonEnv->WsSession(), iSysApShutdownImage->ShutdownCoeControlWindow() ); -#ifdef RD_LIGHT_CONTROL_CHANGE - // NSPS Plugin has been loaded, inform lights controller that in can activate key event forwarding - iSysApLightsController->KeyEventForwardingReady(); -#endif // RD_LIGHT_CONTROL_CHANGE + RProperty::Define( KPSUidCoreApplicationUIs,KCoreAppUIsPowerMenuCustomDialogStatus, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy ); + RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsPowerMenuCustomDialogStatus, ECoreAppUIsPowerMenuCustomDialogUninitialized ); + + + + // TBool result = HbTextResolverSymbian::Init(KPsmlocalisationfile, KtsfilePath); + + TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: END") ) ); + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::FreeResources() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::FreeResources() + { + TRACES( RDebug::Print( _L("CSysApAppUi::FreeResources") ) ); + delete iSysApBatteryInfoController; + delete iSysApPsmController; + //delete iVariantAccState; + + delete iSysApAudioRoutingObserver; + + if ( iSapTimer ) + { + iSapTimer->Cancel(); + delete iSapTimer; + } + //Powermenu + if (iPowerMenuDialog!=NULL) + { + //PowerMenu already exist + delete iPowerMenuDialog; + iPowerMenuDialog = NULL; + } + + RWindowGroup groupWin = iCoeEnv->RootWin(); + groupWin.CancelCaptureKey( iCapturedEKeyPowerOff ); + groupWin.CancelCaptureKeyUpAndDowns( iCapturedEKeyPowerOffUpAndDowns ); + + delete iSysApDefaultKeyHandler; + delete iSysApCenRepLightSettingsObserver; + delete iSysApCenRepBtObserver; + delete iSysApCenRepHacSettingObserver; + delete iSysApCenRepController; - // Create HAC setting observer now because telephony state may change before entering to normal state - TRACES( RDebug::Print( _L("CCSysApAppUi::ConstructL trying CSysApCenRepHacSettingObserver::NewL") ) ); - iSysApCenRepHacSettingObserver = CSysApCenRepHacSettingObserver::NewL( *this ); + delete iSysApPubSubObserver; + + delete iSysApLightsController; + delete iSysApFeatureManager; + + delete iSysApCenRepLogsObserver; + delete iSysApOfflineModeController; + + delete iSysApUsbIndicatorController; + delete iKeyguardController; + // delete iHbIndicatorSymbian; + delete iSysApKeyManagement; + iSysApKeyManagement = NULL; + + REComSession::FinalClose(); + iResourcesFreed = ETrue; + TRACES( RDebug::Print( _L("CSysApAppUi::FreeResources:END") ) ); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::PrepareToExit() +// --------------------------------------------------------------------------- +void CSysApAppUi::PrepareToExit() + { + TRACES("CSysApAppUi::PrepareToExit()"); + CEikAppUi::PrepareToExit(); + } + - TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: END") ) ); +// ---------------------------------------------------------------------------- +// CSysApAppUi::StateOfProperty() +// ---------------------------------------------------------------------------- +TInt CSysApAppUi::StateOfProperty( const TUid& aCategory, const TUint aKey ) const + { + TInt err( KErrNone ); + TInt value( 0 ); + err = RProperty::Get( aCategory, aKey, value ); + if ( err ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::StateOfProperty. RProperty::Get: err=%d"), err ) ); + return err; + } + return value; + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::OfflineModeActive() +// ---------------------------------------------------------------------------- +TBool CSysApAppUi::OfflineModeActive() + { + if(iSysApOfflineModeController) + { + return iSysApOfflineModeController->OfflineModeActive(); + } + else + { + return EFalse; + } + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::GoOnlineL() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::GoOnlineL( TBool /* aDoProfileChange */ ) + { + if ( iSysApFeatureManager->OfflineModeSupported() ) + { +// TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: going from off-line into on-line: aDoProfileChange=%d" ), aDoProfileChange ) ); + iActivateBt = iSysApOfflineModeController->MustBtBeActivated(); + iSysApOfflineModeController->SwitchFromOfflineToOnlineModeL(); + TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: iActivateBt = %d" ), iActivateBt ) ); + } } // ---------------------------------------------------------------------------- -// CSysApAppUi::~CSysApAppUi() +// CSysApAppUi::GoOfflineL() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::GoOfflineL() + { + if ( iSysApFeatureManager->OfflineModeSupported() ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::GoOfflineL" ) ) ); + iDeactivateBt = ETrue; + iSysApOfflineModeController->SwitchFromOnlineToOfflineModeL(); + } + } + +#ifndef SYSAP_USE_STARTUP_UI_PHASE +// need to configure the above macro. +#else // SYSAP_USE_STARTUP_UI_PHASE + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleUiReadyAfterBootL() +// Called when startup UI activities has been finished +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleUiReadyAfterBootL() + { + TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL" ) ) ); + TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); + + UpdateBatteryBarsL( state ); + DoSwStateNormalConstructionL(); + HandleAccessoryProfileInStartupL(); + + if ( !iSysApPsmController ) // created here if first state change has not occurred yet + { + iSysApPsmController = CSysApPsmController::NewL( *this ); + } + + if ( iSysApPsmController ) + { + if ( iCharging ) // if charger is connected on boot PSM queries may need to be shown + { + HandleChargingStatusL( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) ); + } + } + + TInt batteryStatus = StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryStatus ); + TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: batteryStatus %d" ), batteryStatus ) ); + if( batteryStatus == EBatteryStatusLow || batteryStatus == EBatteryStatusEmpty ) + { + // low and empty battery states are informed to the user in device startup + HandleBatteryStatusL( batteryStatus ); + } + else if ( iSysApPsmController && !iCharging ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: batteryStatus %d, iCharging %d -> disable partial psm" ), batteryStatus, iCharging ) ); + + iSysApPsmController->BatteryLow( EFalse ); + iSysApPsmController->DoEnablePartialPsm( EFalse ); + } + + if ( ! iSysApUsbIndicatorController ) + { + TRAPD ( usbErr, iSysApUsbIndicatorController = CreateSysApUsbIndicatorL( *this ) ); + if ( usbErr ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: error in constructing USB ind. controller %d" ), usbErr ) ); + } + } + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState) +// This method is not called after boot has finished. // ---------------------------------------------------------------------------- +void CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState) + { + TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: %d" ), aSwState ) ); + + TRAPD( simChangedErr, DoSimChangedFromPreviousBootL() ); + TRACES( RDebug::Print( _L("CSysApAppUi::DoStateChangedL: simChangedErr = %d" ), simChangedErr ) ); + simChangedErr = simChangedErr; // suppress 'variable not used' warning + LogsObserverL().HandleSimChangedCheckDoneL(); + + if ( iSysApFeatureManager->PowerSaveSupported() ) + { + // create controller before checking battery state, so that power saving can be enabled during boot if needed + if ( !iSysApPsmController ) // created only in first state change + { + iSysApPsmController = CSysApPsmController::NewL( *this ); + } + + // in charger boot explicitly disable power save mode + if ( aSwState == RStarterSession::ECharging ) + { + iSysApPsmController->ChargerConnected(); + iSysApPsmController->DoEnablePartialPsm( EFalse ); // disable power save now + } + } + + if ( aSwState == RStarterSession::ECharging || aSwState == RStarterSession::EAlarm ) + { + TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); + //Also Charging status will be updated with the following function. + UpdateBatteryBarsL( state ); + } + + if( IsStateNormal() ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL to normal state.") ) ); + + iSysApBtController = CreateSysApBtControllerL( *this ); + iSysApBtSapController = CreateSysApBtSapControllerL( *this ); + + if ( iActivateBt ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL Activating BT" ) ) ); + SetBtPowerState( ETrue ); + } + + if ( iDeactivateBt ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL Deactivating BT" ) ) ); + SetBtPowerState( EFalse ); + } + + if ( !StarterSession().Handle() ) + { + User::Leave( KErrBadHandle ); + } + +/* if ( !KeyLock().Handle() ) + { + User::Leave( KErrBadHandle ); + } +*/ +#ifdef __SYSAP_MODULE_TEST + ModuleTestShowUiNoteL( _L("SysAp: SW state normal!") ); +#endif + } + + // Allow lights + iSysApLightsController->AllowLightsOn(); + } + +#endif // SYSAP_USE_STARTUP_UI_PHASE + CSysApAppUi::~CSysApAppUi() { TRACES( RDebug::Print( _L("~CSysApAppUi() started") ) ); if( !iResourcesFreed ) - { + { FreeResources(); - - iStarterSession.Close(); - - } - - delete iSysApShutdownImage; - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - if (iSysApShutdownAnimation) - { - RemoveFromStack( iSysApShutdownAnimation ); -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - delete iSysApShutdownAnimation; -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - delete iProfileNote; - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - if( iAnimTimer ) - { - iAnimTimer->Cancel(); - } - delete iAnimTimer; -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - delete iSysApPowerKeyMenuObserver; - + } delete iSysApStartupController; - -#ifdef RD_MULTIPLE_DRIVE - iInsertedMemoryCards.Close(); - delete iSysApDriveEjectHandler; - delete iSysApDriveUnlockHandler; - delete iSysApDriveList; -#endif // RD_MULTIPLE_DRIVE - - TRACES( RDebug::Print( _L("~CSysApAppUi() completed") ) ); + } + +TBool CSysApAppUi::ResourcesFreed() const + { + return iResourcesFreed; } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleLocationPrivacyIndicatorL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleLocationPrivacyIndicatorL( const TInt aState ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleLocationPrivacyIndicatorL() state=%d"), aState ) ); - if ( iSysApFeatureManager->LocationPrivacySupported() ) - { - // Phase 1. Set all Location Privacy indicators off - if ( iSysApLocationPrivacyIndicator->iIndicatorIdAcceptAll != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdRejectAll, EAknIndicatorStateOff ); - } - if ( iSysApLocationPrivacyIndicator->iIndicatorIdRejectAll != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdRejectAll, EAknIndicatorStateOff ); - } - if ( iSysApLocationPrivacyIndicator->iIndicatorIdAlwaysAsk != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdAlwaysAsk, EAknIndicatorStateOff ); - } - if ( iSysApLocationPrivacyIndicator->iIndicatorIdIndividualPrivacy != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdIndividualPrivacy, EAknIndicatorStateOff ); - } - // Phase 2. Set the required Location Privacy indicator on - switch ( aState ) - { - case EPSLocPrivAcceptAll: - if ( iSysApLocationPrivacyIndicator->iIndicatorIdAcceptAll != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdAcceptAll, EAknIndicatorStateOn ); - } - break; - case EPSLocPrivRejectAll: - if ( iSysApLocationPrivacyIndicator->iIndicatorIdRejectAll != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdRejectAll, EAknIndicatorStateOn ); - } - break; - case EPSLocPrivAlwaysAsk: - if ( iSysApLocationPrivacyIndicator->iIndicatorIdAlwaysAsk != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdAlwaysAsk, EAknIndicatorStateOn ); - } - break; - case EPSLocPrivIndividualPrivacy: - if ( iSysApLocationPrivacyIndicator->iIndicatorIdIndividualPrivacy != KSysApNoIndicator ) - { - SetIndicatorStateL( iSysApLocationPrivacyIndicator->iIndicatorIdIndividualPrivacy, EAknIndicatorStateOn ); - } - break; - default: - break; - } - } +void CSysApAppUi::ShowExampleUiNoteL( const TDesC& noteText )const + { + // QString msg = QString::fromUtf16(aStringPointer.Ptr(),aStringPointer.Length()); + TRACES( RDebug::Print( _L("CSysApAppUi::ShowExampleUiNoteL:: constructing CHbDeviceMessageBoxSymbian:BeGIN") ) ); + CHbDeviceMessageBoxSymbian *note = CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EInformation); + CleanupStack::PushL(note); + TRACES( RDebug::Print( _L("CSysApAppUi::ShowExampleUiNoteL:: construction of CHbDeviceMessageBoxSymbian:END") ) ); + // HbMessageBox *note = new HbMessageBox (HbMessageBox ::MessageTypeInformation); + note->SetTextL(noteText); + // note->SetTimeout(HbPopup::NoTimeout); + note->SetTimeout(5); + TRACES( RDebug::Print( _L("CSysApAppUi:: Display of CHbDeviceMessageBoxSymbian::Begin") ) ); + note->ShowL(); + TRACES( RDebug::Print( _L("CSysApAppUi:: Display of CHbDeviceMessageBoxSymbian::End") ) ); + CleanupStack::PopAndDestroy(note); } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType ) -// ---------------------------------------------------------------------------- - -TKeyResponse CSysApAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType ) +void CSysApAppUi::ExecQueryL( TSysapQuery aQuery, TDes8& aReturn ) { - if ( ! iShutdownStarted ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL: aKeyEvent.iCode:%d, aKeyEvent.iScanCode:%d, aType:%d, iIgnoreNextPowerKeyUpEvent:%d, iPowerKeyPopupMenuActive:%d, iLastPowerKeyWasShort:%d, iPowerKeyPopupMenuDismissed:%d"), - aKeyEvent.iCode, aKeyEvent.iScanCode, aType, iIgnoreNextPowerKeyUpEvent, iPowerKeyPopupMenuActive, iLastPowerKeyWasShort, iPowerKeyPopupMenuDismissed ) ); - -#ifdef _DEBUG - // camery latency measurement environment instrumentation, don't remove - if ( aType == EEventKey && aKeyEvent.iCode == EKeyCamera ) - { - TRACES( RDebug::Print( _L("e_KEY_EVENT_SENDING 0") ) ); - } -#endif // _DEBUG - - TKeyResponse response( EKeyWasNotConsumed ); - if (iSysApKeyManagement && aKeyEvent.iCode != EKeyPowerOff && aKeyEvent.iCode != 'E') - { - response = iSysApKeyManagement->HandleKeyEventL(aKeyEvent, aType ); - } - - if( aType == EEventKey ) - { - switch ( aKeyEvent.iCode ) - { -#ifdef _DEBUG - case 'E': //For testing - Exit(); - break; -#endif - case EKeyPowerOff: - //Short power key press - iKeyBoardRepeatCount++; - if( aKeyEvent.iRepeats == 0 ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::HandleKeyEventL, Short powerkey") ) ); - iLastPowerKeyWasShort = ETrue; - HandleShortPowerKeyPressedL(); - iIgnoreNextPowerKeyRepeats = EFalse; - } - //Long power key press - else if( aKeyEvent.iRepeats > 0 && iKeyBoardRepeatCount >= iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApPowerkeyRepeatcount )) - { - iKeyBoardRepeatCount = -1; - TRACES( RDebug::Print(_L("CSysApAppUi::HandleKeyEventL, Long powerkey") ) ); - iLastPowerKeyWasShort = EFalse; - HandleLongPowerKeyPressedL(); - } - break; - - default: - { - TKeyResponse response = EKeyWasNotConsumed; - if (iSysApKeyManagement) - { - response = iSysApKeyManagement->HandleKeyEventL(aKeyEvent, aType ); - } - - if ( response == EKeyWasNotConsumed ) // none of the plugins consumed the key, offer it to default handling - { - iSysApDefaultKeyHandler->HandleKeyEventL( aKeyEvent, aType ); - } - } - break; - } - } - else if( aType == EEventKeyUp ) - { - if( aKeyEvent.iScanCode == EStdKeyDevice2 ) - { - if ( iIgnoreNextPowerKeyUpEvent ) - { - if ( !iPowerKeyPopupMenuDismissed ) // If the popup menu has been dismissed, do nothing - { - iPowerKeyPopupMenuActive = ETrue; - iIgnoreNextPowerKeyUpEvent = EFalse; - } - } - else if( iLastPowerKeyWasShort ) - { - if ( iPowerKeyPopupMenuActive ) - { - if ( iGlobalListQuery ) - { - if ( iSysApFeatureManager->NoPowerKeySupported() ) - { - CancelGlobalListQuery(); - } - else - { - iGlobalListQuery->MoveSelectionDown(); - } - } - } - } - - } - } - - TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL:ended, aKeyEvent.iCode:%d, aKeyEvent.iScanCode:%d, aType:%d, iIgnoreNextPowerKeyUpEvent:%d, iPowerKeyPopupMenuActive:%d, iLastPowerKeyWasShort:%d, iPowerKeyPopupMenuDismissed:%d"), - aKeyEvent.iCode, aKeyEvent.iScanCode, aType, iIgnoreNextPowerKeyUpEvent, iPowerKeyPopupMenuActive, iLastPowerKeyWasShort, iPowerKeyPopupMenuDismissed ) ); - } - else // shutdown started - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL: aKeyEvent.iCode:%d, aKeyEvent.iScanCode:%d, aType:%d"), - aKeyEvent.iCode, aKeyEvent.iScanCode, aType ) ); - - // When shutdown has been started, only device mode key events are passed to plug-in framework - // This for enabling plug-in activities during shutdown animation - if ( IsDeviceModeKey( aKeyEvent ) ) // Other key events are not passed, because they must cancel the shutdown animation as stated in UI spefication - { - if ( aType == EEventKey && iSysApKeyManagement ) - { - iSysApKeyManagement->HandleKeyEventL( aKeyEvent, aType ); - } - } - #ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION - else if ( aType == EEventKey && iSysApShutdownAnimation && !iShutdownContinued ) - { - if ( aKeyEvent.iCode != EKeyPowerOff || iLastPowerKeyWasShort ) - { - iSysApShutdownAnimation->Cancel(); - NotifyShutdownAnimationSkip(); - } - } - - #endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL: ended") ) ); - } - return EKeyWasConsumed; + ExecQueryL( aQuery, aReturn, KNullDesC8 ); } // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleCommandL( TInt aCommand) +// CSysApAppUi::ExecQueryL // ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleCommandL( TInt aCommand ) +// +void CSysApAppUi::ExecQueryL( TSysapQuery aQuery, TDes8& aReturn, const TDesC8& /*aParam*/ ) { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleCommandL aCommend: %d"), aCommand ) ); - switch ( aCommand ) + TRACES( RDebug::Print(_L("CSysApAppUi::ExecQueryL: aQuery=%d"), aQuery ) ); + + switch ( aQuery ) { - case EEikCmdExit: // EAknCmdExit - Exit(); + case EGetHwrmLight: // get handle to HWRM client session. Returns CHWRMLight*. + { + THwrmLightBuf retBuf( iSysApLightsController->GetHwrmLight() ); + aReturn.Copy( retBuf ); + } break; + + case EGetKeylock: // get handle to keylock client session. Returns RAknKeylock2*. + { + // do nothing + } + break; + + default: + __ASSERT_DEBUG( EFalse, User::Panic( _L("CSysApAppUi::ExecQueryL: Invalid query"), KErrArgument ) ); + User::Leave( KErrArgument ); break; } } // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleApplicationSpecificEventL(TInt aType,const TWsEvent& aEvent) +// CSysApAppUi::ExecCommandL // ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleApplicationSpecificEventL(TInt aType,const TWsEvent& aEvent) +// +void CSysApAppUi::ExecCommandL( TSysapCommand aCommand ) { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleApplicationSpecificEventL: aType:%d"), aType ) ); + ExecCommandL( aCommand, KNullDesC8 ); + } - CAknAppUi::HandleApplicationSpecificEventL(aType, aEvent); - - if ( ResourcesFreed() ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleApplicationSpecificEventL: discarded, shutting down") ) ); - return; - } - - switch( aType ) +// ---------------------------------------------------------------------------- +// CSysApAppUi::ExecCommandL +// ---------------------------------------------------------------------------- +// +void CSysApAppUi::ExecCommandL( TSysapCommand aCommand, const TDesC8& /* aParam */ ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::ExecCommandL: aCommand=%d"), aCommand ) ); + + switch ( aCommand ) { - case EEikKeyLockEnabled: - iKeyLockEnabled = ETrue; - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive, 1 ); - SetIndicatorStateL( EAknIndicatorKeyguard, EAknIndicatorStateOn ); - iSysApLightsController->KeylockStateChangedL( ETrue ); - break; - case EEikKeyLockDisabled: - iKeyLockEnabled = EFalse; - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive, 0 ); - SetIndicatorStateL( EAknIndicatorKeyguard, EAknIndicatorStateOff ); - if (! iDeviceLockEnabled ) - { - iSysApLightsController->KeylockStateChangedL( EFalse ); - if ( iSysApFeatureManager->MmcHotSwapSupported() ) - { - if ( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) != EPSCTsyCallStateRinging && StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) != EPSCTsyCallStateAlerting ) - { - RunUnlockNotifierL(); - } - } - } - break; - case EEikKeyLockPowerKeyPressed: //sent when power key is captured by keylockserver - HandleShortPowerKeyPressedL(); - break; - - case EEikKeyLockLightsOnRequest: - iSysApLightsController->SetLightsOnUnlockNoteL(); - break; - - case EEikEcsQueryLights: // emergency note is shown - iSysApLightsController->SetLightsOnEcsQueryL(); - break; - - case EEikSecurityQueryLights: // for device lock security query - iSysApLightsController->SetLightsOnSecurityQueryL(); + case EResetKeyguardState: // reset the internal keyguard flags of the SysAp, except for iKeyLockOnBeforeCradle + iKeyLockOnBeforeCall = EFalse; + iKeyLockOnBeforeAlarm = EFalse; break; default: + // do nothing in release builds since no harm is done + __ASSERT_DEBUG( EFalse, User::Panic( _L("CSysApAppUi::ExecCommandL: Invalid command"), KErrArgument ) ); break; + } + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::TimerExpiredL() +// ---------------------------------------------------------------------------- +void CSysApAppUi::TimerExpiredL() + { +/* + * Not suppported , will take care in wk25 + * #ifndef RD_MULTIPLE_DRIVE + * CloseUIAppsInHotSwapL(); + * #endif // RD_MULTIPLE_DRIVE +*/ + } + + + // ---------------------------------------------------------------------------- +// CSysApAppUi::KeyLockState() const +// ---------------------------------------------------------------------------- + +TBool CSysApAppUi::KeyLockState() const + { + return iKeyLockEnabled; + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::DeviceLockState() const +// ---------------------------------------------------------------------------- + +TBool CSysApAppUi::DeviceLockState() const + { + return iDeviceLockEnabled; + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::SysApFeatureManager +// ---------------------------------------------------------------------------- + +CSysApFeatureManager& CSysApAppUi::SysApFeatureManager() + { + __ASSERT_DEBUG( iSysApFeatureManager, User::Panic( _L("iSysApFeatureManager == NULL"), KErrBadHandle ) ); + + return *iSysApFeatureManager; + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::ActivateKeyeventForwardingForLights() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::ActivateKeyeventForwardingForLights(TBool aActivate) + { + if( iSysApNspsHandler ) + { + if ( aActivate ) + { + iSysApNspsHandler->ActivateKeyeventForwardingForLights(); } + else + { + iSysApNspsHandler->DeActivateKeyeventForwardingForLights(); + } + } + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::StarterSession() +// ---------------------------------------------------------------------------- + +RStarterSession& CSysApAppUi::StarterSession() + { + if ( !iStarterSession.Handle() ) + { + // All server connections are tried to be made KTriesToConnectServer times because occasional + // fails on connections are possible at least on some servers + TRACES( RDebug::Print( _L("CSysApAppUi::StarterSession: trying RStarterSession::Connect()") ) ); + TInt thisTry = 0; + TInt err; + while ( ( err = iStarterSession.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer ) + { + User::After( KTimeBeforeRetryingServerConnection ); + } + + if ( err != KErrNone ) + { + // What do in error case? + TRACES( RDebug::Print( _L("CSysApAppUi::StarterSession: RStarterSession::Connect() failed with %d"), err ) ); + } + } + + return iStarterSession; + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::SetBtPowerState() +// ---------------------------------------------------------------------------- +TInt CSysApAppUi::SetBtPowerState( TBool aBtState ) + { + if ( iSysApBtController ) + { + return iSysApBtController->SetPowerState( aBtState ); + } + else + { + return KErrNotReady; + } + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::SetStarterState() +// ---------------------------------------------------------------------------- + +TInt CSysApAppUi::SetStarterState( const RStarterSession::TGlobalState aState ) + { + if ( iSysApStartupController->GlobalStateChangeAllowed( aState ) ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::SetStarterState: aState=%d" ), aState ) ); + return StarterSession().SetState( aState ); + } + else + { + TRACES( RDebug::Print( _L("CSysApAppUi::SetStarterState: aState=%d - not allowed" ), aState ) ); + return KErrNone; + } + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::SetNetworkConnectionAllowed() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::SetNetworkConnectionAllowed( TCoreAppUIsNetworkConnectionAllowed aNetworkConnectionAllowed ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::SetNetworkConnectionAllowed: status: %d" ), aNetworkConnectionAllowed ) ); + + iSysApCenRepController->SetInt( KCRUidCoreApplicationUIs, KCoreAppUIsNetworkConnectionAllowed, (TInt) aNetworkConnectionAllowed ); + + // Also set the Symbian PS key used for the same purpose: + RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, aNetworkConnectionAllowed ? ESAPhoneOn : ESAPhoneOff); + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::BluetoothPowerMode() +// ---------------------------------------------------------------------------- +TInt CSysApAppUi::BluetoothPowerMode() const + { + return iSysApCenRepBtObserver->BluetoothPowerMode(); + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::SimSupported() +// ---------------------------------------------------------------------------- +TBool CSysApAppUi::SimSupported() + { + return iSysApFeatureManager->SimSupported(); + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::BtSapEnabled() +// ---------------------------------------------------------------------------- + +TBool CSysApAppUi::BtSapEnabled() + { + if ( iSysApBtSapController ) + { + return iSysApBtSapController->BtSapEnabled(); + } + return EFalse; } // ---------------------------------------------------------------------------- -// CSysApAppUi::InitializeStatusPaneAreaL() +// CSysApAppUi::OfflineModeChangedL() +// ---------------------------------------------------------------------------- +void CSysApAppUi::OfflineModeChangedL() + { +#ifdef SYSAP_USE_STARTUP_UI_PHASE + // if UI is not ready, don't update indicators + if ( !UiReady() ) + { + return; + } +#endif // SYSAP_USE_STARTUP_UI_PHASE + +#if 0 // Not used as of now + SetHacIndicatorL(); +#endif //0 + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::UiReady() +// // ---------------------------------------------------------------------------- -void CSysApAppUi::InitializeStatusPaneAreaL() +TBool CSysApAppUi::UiReady() const { - TRACES( RDebug::Print( _L("CSysApAppUi::InitializeStatusPaneAreaL(): START") ) ); - TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - - //Also Charging status will be updated with the following function. - UpdateBatteryBarsL( state ); +#ifdef SYSAP_USE_STARTUP_UI_PHASE + return iSysApStartupController->UiReady(); +#else // SYSAP_USE_STARTUP_UI_PHASE + // if startup UI phase information is not used, global system state normal is handled as UI idle state + return IsStateNormal(); +#endif // SYSAP_USE_STARTUP_UI_PHASE + } -#ifdef SYSAP_USE_STARTUP_UI_PHASE - if ( OfflineModeActive() ) - { - UpdateSignalBarsL( KAknSignalOffLineMode ); - } - else - { - UpdateSignalBarsL(); - } -#else - UpdateSignalBarsL(); -#endif // SYSAP_USE_STARTUP_UI_PHASE - - SetSignalIndicatorL(); - SetIhfIndicatorL(); - SetHacIndicatorL(); - LogsObserverL().HandleUiReadyL(); - - if ( iSysApEtelConnector ) - { - iSysApEtelConnector->ReadSimSmsStoreStatusInStartup(); - } - SetEnvelopeIndicatorL(); - - TRACES( RDebug::Print( _L("CSysApAppUi::InitializeStatusPaneAreaL(): accessories") ) ); - - TAccMode accessoryState(EAccModeHandPortable); - if ( iSysApAccessoryObserver ) - { - accessoryState = iSysApAccessoryObserver->GetAccessoryMode(); - } +// ---------------------------------------------------------------------------- +// CSysApAppUi::CompleteShutdown() +// ---------------------------------------------------------------------------- - if( accessoryState == EAccModeWiredHeadset || - accessoryState == EAccModeWirelessHeadset || - accessoryState == EAccModeHeadphones ) - { - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if( accessoryState == EAccModeLoopset ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if( accessoryState == EAccModeTextDevice ) +void CSysApAppUi::CompleteShutdown( const TBool aReset, const TInt aResetReason ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::CompleteShutdown(): START" ) ) ); + + iCheckLongPowerKeyEvent = ETrue; + + PrepareForShutdownImage();//SysAp's internal preparation for ShutDown with image + + FreeResources(); + + if ( aReset ) { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if( accessoryState == EAccModeWiredCarKit || accessoryState == EAccModeWirelessCarKit ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if( accessoryState == EAccModeTVOut ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if (accessoryState == EAccModeHDMI ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOn ); - } - else // all indicators off - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - - TRACES( RDebug::Print( _L("CSysApAppUi::InitializeStatusPaneAreaL(): msg") ) ); - state = StateOfProperty( KUidSystemCategory, KUidOutboxStatusValue ); - if( state == ESADocumentsInOutbox ) - { - SetIndicatorStateL( EAknIndicatorOutbox, EAknIndicatorStateOn ); - } - else - { - SetIndicatorStateL( EAknIndicatorOutbox, EAknIndicatorStateOff ); - } - - state = StateOfProperty( KAlarmServerPubSubCategory, KWakeupAlarmPubSubKey ); - - if( state == EActiveWakeupAlarmSet ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::InitializeStatusPaneAreaL called the SetIndicatorStateL with EActiveWakeupAlarmSet "))); - SetIndicatorStateL( EAknIndicatorAlarmClock, EAknIndicatorStateOn ); + __ASSERT_DEBUG( aResetReason >= RStarterSession::ELanguageSwitchReset && + aResetReason <= RStarterSession::EDataRestoreReset, + User::Invariant() ); + StarterSession().Reset( static_cast( aResetReason ) ); } else { - TRACES( RDebug::Print(_L("CSysApAppUi::InitializeStatusPaneAreaL called the SetIndicatorStateL with EActiveNoWakeupAlarmsSet "))); - SetIndicatorStateL( EAknIndicatorAlarmClock, EAknIndicatorStateOff ); + StarterSession().Shutdown(); } - state = StateOfProperty( KIrdaPropertyCategory, KIrdaStatus ); - if( state == TIrdaStatusCodes::EIrLoaded || state == TIrdaStatusCodes::EIrDisconnected || state == TIrdaStatusCodes::EIrBlocked ) + StarterSession().Close(); + + TRACES( RDebug::Print(_L("CSysApAppUi::CompleteShutdown(): END" ) ) ); + } + + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::DoShutdownL( const TBool aReset, const TSWStartupReason aSWStartupReason ) +// ---------------------------------------------------------------------------- + +void CSysApAppUi::DoShutdownL( const TBool aReset, const TInt aResetReason ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: aResetReason:%d, aReset:%d" ), + aResetReason, aReset ) ); +#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION + TBool animationenabled( EFalse ); +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION + + if( OkToInitiateShutdown() ) { - SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateAnimate ); - } - else if( state == TIrdaStatusCodes::EIrConnected ) - { - SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateOn ); + TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: Was OkToToInitiateShutdown" ) ) ); + + + if ( !aReset && iSysApFeatureManager->Supported(KSysApFeatureIdGoodbyeNote) ) + { + // show shutdown note + } + + if( !aReset ) + { + #ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION +// TRAPD( err, ShowAnimationL() ); +// if ( err ) + { + // TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL ShowAnimationL() leaved: %d" ), err ) ); + CompleteShutdown(aReset, aResetReason); + } + } + else // aReset + { + CompleteShutdown(aReset, aResetReason); + } + #else // RD_STARTUP_ANIMATION_CUSTOMIZATION + TRAPD( err, animationenabled = ShowAnimationL() ); + if ( err ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL ShowAnimationL() leaved: %d" ), err ) ); + } + } + + if ( !animationenabled ) + { + CompleteShutdown(aReset, aResetReason); + } + #endif // RD_STARTUP_ANIMATION_CUSTOMIZATION } else { - SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateOff ); - } - - iSysApCenRepCallForwardingObserver->UpdateCallForwardingIndicatorsL(); - - iSysApCenRepMsgWaitingObserver->UpdateMessageWaitingIndicatorsL(); - - state = StateOfProperty( KPSUidNetworkInfo, KNWHomeZoneStatus ); - if( state == ENWNone || state == ENWCityZone ) - { - SetIndicatorStateL( EAknIndicatorHomeZone, EAknIndicatorStateOff ); - } - else if( state == ENWHomeZone ) - { - SetIndicatorStateL( EAknIndicatorHomeZone, EAknIndicatorStateOn ); + TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: Was not OkToToInitiateShutdown" ) ) ); } - - // Initialize WLan state - state = StateOfProperty( KPSUidWlan, KPSWlanIndicator ); - HandleWlanIndicatorL(state); - - // Initialize Tarm state - state = StateOfProperty( KPSUidCoreApplicationUIs, KCoreAppUIsTarmIndicator ); - HandleTarmIndicatorL(state); - - TRACES( RDebug::Print( _L("CSysApAppUi::InitializeStatusPaneAreaL(): END") ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleWlanIndicator() -// ---------------------------------------------------------------------------- -void CSysApAppUi::HandleWlanIndicatorL( TInt aValue ) - { - if ( aValue == EPSWlanIndicatorAvailable ) - { - SetIndicatorStateL( EAknIndicatorWlanActive, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActiveSecure, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanAvailable, EAknIndicatorStateOn ); - } - else if ( aValue == EPSWlanIndicatorActive ) - { - SetIndicatorStateL( EAknIndicatorWlanAvailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActiveSecure, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActive, EAknIndicatorStateOn ); - } - else if ( aValue == EPSWlanIndicatorActiveSecure ) - { - SetIndicatorStateL( EAknIndicatorWlanAvailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActive, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActiveSecure, EAknIndicatorStateOn ); - } - else // No indication required - { - SetIndicatorStateL( EAknIndicatorWlanAvailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActive, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorWlanActiveSecure, EAknIndicatorStateOff ); - } + TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: END" ) ) ); } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleTarmIndicatorL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleTarmIndicatorL( TInt aValue ) - { - if ( aValue == ECoreAppUIsTarmTerminalSecurityOnIndicatorOn ) - { - SetIndicatorStateL( EAknIndicatorTARM, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTARMModuleOn, EAknIndicatorStateOn ); - } - else if ( aValue == ECoreAppUIsTarmMngActiveIndicatorOn ) - { - SetIndicatorStateL( EAknIndicatorTARMModuleOn, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTARM, EAknIndicatorStateOn ); - } - else - { - SetIndicatorStateL( EAknIndicatorTARM, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTARMModuleOn, EAknIndicatorStateOff ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleShortPowerKeyPressedL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleShortPowerKeyPressedL() - { - TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ); - - TRACES ( - RDebug::Print( - _L("CSysApAppUi::HandleShortPowerKeyPressedL() callState:%d, iDeviceLockEnabled:%d" ), - callState, - iDeviceLockEnabled ); - ); - iSysApLightsController->PowerKeyPressedL(); - - RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsHideAlarm, ECoreAppUIsHideAlarm ); - if( UiReady() && !iDeviceLockEnabled ) - { - if ( iPowerKeyPopupMenuActive ) - { - //Do nothing here. EEventKeyUp moves selection in the list! - } - else if ( !iKeyLockEnabled - && callState != EPSCTsyCallStateAlerting - && callState != EPSCTsyCallStateRinging - && callState != EPSCTsyCallStateDialling ) - //Show power key menu - { - ShowPowerKeyPopUpMenuL(); - } - } - else - { - TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); - - if( swState == ESwStateAlarm ) - //From Alarm state even a short press causes shutdown but charger state need to be checked - { - TInt chargerState( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) ); - if( chargerState == EChargingStatusNotConnected ) - //shutdown +/* +---------------------------------------------------------------------------- +CSysApAppUi::IsEncryptionOperationOngoingL() +Introduced the code as a part of Sub : 405-3362 - Power Management SUB for ES +recapture functionalities in platform which support multidrive as well. +------------------------------------------------------------------------------- +*/ +TBool CSysApAppUi::IsEncryptionOperationOngoingL() const + { + TBool deFeatureSupported(EFalse); + FeatureManager::InitializeLibL(); + deFeatureSupported = FeatureManager::FeatureSupported( KFeatureIdFfDeviceEncryptionFeature); + FeatureManager::UnInitializeLib(); + + if(deFeatureSupported) + { + /** + * Store the last memory status changed + * 0: Idle. It can be Encrypted or Decrypted + * 1: Encrypting + * 2: Decrypting + **/ + + RProperty deProperty; + User::LeaveIfError(deProperty.Attach(KDevEncProtectedUid, KDevEncOperationKey,EOwnerThread)); + TInt deValue = 0; + if((deProperty.Get(deValue)== KErrNone)&&( deValue == EOpEncrypting || deValue == EOpDecrypting)) { - StartShutDownTimerOnAlarmAndChargingStates(); + deProperty.Close(); + return ETrue; } else - //to charging state { - SetStarterState( RStarterSession::ECharging ); + deProperty.Close(); + return EFalse; } } - } + else + { + return EFalse; + } } // ---------------------------------------------------------------------------- @@ -1104,8 +969,8 @@ TInt swState; RProperty::Get( KPSUidStartup, KPSGlobalSystemState, swState ); - - iSysApLightsController->PowerKeyPressedL(); + + iSysApLightsController->PowerKeyPressedL(); //need to handle later. if( swState == ESwStateStartingCriticalApps || swState == ESwStateSelfTestOK || @@ -1121,10 +986,7 @@ { if( iPowerKeyPopupMenuActive ) { - if ( iGlobalListQuery ) - { - iGlobalListQuery->SelectItem(); - } + // do nothing } else if( !iIgnoreNextPowerKeyRepeats ) { @@ -1154,1101 +1016,356 @@ } // ---------------------------------------------------------------------------- -// CSysApAppUi::FreeResources() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::FreeResources() - { - TRACES( RDebug::Print( _L("CSysApAppUi::FreeResources") ) ); - - delete iSysApBatteryInfoController; - delete iSysApPsmController; - - delete iSysApAudioRoutingObserver; - - delete iProfileNamesArray; - iProfileNamesArray = NULL; - - if ( iTimer ) - { - iTimer->Cancel(); - delete iTimer; - } - - if ( iSapTimer ) - { - iSapTimer->Cancel(); - delete iSapTimer; - } - - if ( iSysApTimer ) - { - iSysApTimer->Cancel(); - delete iSysApTimer; - } - - delete iGlobalListQuery; - - RWindowGroup groupWin = iCoeEnv->RootWin(); - groupWin.CancelCaptureKey( iCapturedEKeyPowerOff ); - groupWin.CancelCaptureKeyUpAndDowns( iCapturedEKeyPowerOffUpAndDowns ); - - delete iSysApDefaultKeyHandler; - - if ( iProfileEngine ) - { - iProfileEngine->Release(); - } - - delete iSysApSsSettingsObserver; - delete iSysApEtelConnector; - - delete iSysApProfileObserver; - delete iSysApNspsHandler; - delete iSysApKeySndHandler; - delete iSysApCenRepMsgWaitingObserver; - delete iSysApCenRepCallForwardingObserver; - delete iSysApConnectionMonitorObserver; - delete iSysApCenRepLightSettingsObserver; - delete iSysApCenRepLogsObserver; - delete iSysApCenRepBtObserver; -// delete iSysApCenRepFmTxObserver; - delete iSysApCenRepHacSettingObserver; - delete iSysApCenRepController; - - delete iSysApPubSubObserver; - - delete iSysApMMCObserver; - delete iSysApMsgSimMemLowQuery; - delete iSysApWaitNote; - delete iSysApConfirmationQuery; - delete iSysApConfirmationQueryForRestart; - delete iSysApOfflineModeController; - delete iSysApUsbIndicatorController; - delete iSysApBtController; - delete iSysApBtSapController; - delete iSignalNotify; - delete iBatteryNotify; - delete iSysApSystemLock; - delete iSysApLocationPrivacyIndicator; - delete iSysApAccessoryObserver; - delete iSysApMediatorObserver; - - delete iSysApKeyManagement; - iSysApKeyManagement = NULL; - delete iSysApLightsController; - iKeyLock.Close(); - delete iSysApFeatureManager; - - // Cleanup ECom, used by key management and light control - REComSession::FinalClose(); - - iResourcesFreed = ETrue; - TRACES( RDebug::Print( _L("CSysApAppUi::FreeResources:END") ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowUiNoteL( const TSysApNoteIds aNote ) const +// CSysApAppUi::IsDeviceModeKey // ---------------------------------------------------------------------------- -void CSysApAppUi::ShowUiNoteL( const TSysApNoteIds aNote ) const +TBool CSysApAppUi::IsDeviceModeKey( const TKeyEvent& aKeyEvent ) const { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowUiNoteL aNote: %d"), aNote ) ); + return CSysApDefaultKeyHandler::IsDeviceModeKey( aKeyEvent ); + } + - TInt tone( EAvkonSIDNoSound ); - TAknGlobalNoteType noteType( EAknGlobalBatteryLowNote ); - CAknGlobalNote* note = CAknGlobalNote::NewLC(); - TInt secondaryDisplayId(SecondaryDisplay::ECmdNoNote); +// ---------------------------------------------------------------------------- +// CSysApAppUi::ShowShutdownImage +// ---------------------------------------------------------------------------- +// +TInt CSysApAppUi::ShowShutdownImage( TInt aBitmapId ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::ShowShutdownImage") ) ); - switch ( aNote ) + TRAPD( err, ShowShutdownImageL( aBitmapId ) ); + + if ( err != KErrNone ) { - case EBatteryLowNote: - noteType = EAknGlobalBatteryLowNote; - tone = EAvkonSIDBatteryLowTone; - break; - case EBatteryFullNote: - noteType = EAknGlobalBatteryFullNote; - tone = EAvkonSIDInformationTone; - break; - case ERechargeBatteryNote: - iSysApLightsController->BatteryEmptyL( ETrue ); - noteType = EAknGlobalRechargeBatteryNote; - tone = EAvkonSIDRechargeBatteryTone; - break; - case ENotChargingNote: - noteType = EAknGlobalNotChargingNote; - tone = EAvkonSIDWrongCharger; - break; - case EInsertSimNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowInsertSimNote; - break; - case EMemoryCardRemovedWithoutEjectNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowMemoryCardRemovedWithoutEjectNote; - break; - case EGprsSuspendedNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowGprsSuspendedNote; - break; - case EGprsResumedNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowGprsResumedNote; - break; - case EShutdownNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowShutdownNote; - break; - case ECannotActivateOfflineModeNote: - noteType = EAknGlobalErrorNote; - tone = EAvkonSIDErrorTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowCannotActivateOfflineModeNote; - break; - case ECannotDeactivateOfflineModeNote: - noteType = EAknGlobalErrorNote; - tone = EAvkonSIDErrorTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowCannotDeactivateOfflineModeNote; - break; - case EKeypadActiveNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowKeypadActiveNote; - break; -/* case EFmTxAccessoryStandbyNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowFmTxStandbyInAccessoryConnectionNote; - break; - case EFmTxAccessoryForbidsNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowFmTxCannotEnableWhileAccessoryConnectedNote; - break; - case EFmTxVolumeDisabledNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowFmTxVolumeDisabledNote; - break; - case EFmTxOnNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowFmTxTuneRadioToFrequencyNote; - break; - case EFmTxOffNote: - noteType = EAknGlobalInformationNote; - tone = EAvkonSIDInformationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowFmTxDisabledNote; - break; -*/ case EBatteryFullUnplugChargerNote: - noteType = EAknGlobalBatteryFullUnplugNote; - tone = EAvkonSIDInformationTone; - break; - case EUnplugChargerNote: - noteType = EAknGlobalUnplugChargerNote; - tone = EAvkonSIDInformationTone; - break; - case EPowerSaveModeActivated: - noteType = EAknGlobalConfirmationNote; - tone = EAvkonSIDConfirmationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowPowerSavingActivatedNote; - break; - case EPowerSaveModeDeactivated: - noteType = EAknGlobalConfirmationNote; - tone = EAvkonSIDConfirmationTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowPowerSavingDeactivatedNote; - break; - case ECannotActivatePowerSaveMode: - noteType = EAknGlobalWarningNote; - tone = EAvkonSIDWarningTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowCannotActivatePowerSavingNote; - break; - case ECannotDeactivatePowerSaveMode: - noteType = EAknGlobalWarningNote; - tone = EAvkonSIDWarningTone; - secondaryDisplayId = SecondaryDisplay::ECmdShowCannotDeactivatePowerSavingNote; - break; - default: - break; - + TRACES( RDebug::Print(_L("CSysApAppUi::ShowShutdownImageL failed, err=%d"), err ) ); } - TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); - - if( UiReady() || swState == ESwStateSecurityCheck) - { - HBufC* noteStringBuf = NULL; - - switch ( aNote ) - { - case EInsertSimNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_SU_NOTE_INSERT_SIM, iEikonEnv ); - break; - case EMemoryCardRemovedWithoutEjectNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_MEMS_EJECT_ERROR, iEikonEnv ); - note->SetSoftkeys( R_AVKON_SOFTKEYS_OK_EMPTY ); - break; - case EGprsSuspendedNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_GPRS_CONF_GPRS_SUSPENDED, iEikonEnv ); - break; - case EGprsResumedNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_GPRS_CONF_GPRS_RESUMED, iEikonEnv ); - break; - case EShutdownNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_PWRC_INFO_GOODBYE, iEikonEnv); - break; - case ECannotActivateOfflineModeNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_ERR_OFFLINE_UNABLE, iEikonEnv ); - break; - case ECannotDeactivateOfflineModeNote: - noteStringBuf = StringLoader::LoadLC( R_QTN_ERR_OFFLINE_UNABLE_PROFILE, iEikonEnv ); - break; - case EKeypadActiveNote: - if ( iSysApFeatureManager->PenEnabled() ) - { - noteStringBuf = StringLoader::LoadLC( R_QTN_KEYG_CONF_DISPLAY_KEYS_ACTIVE, - iEikonEnv ); - } - else - { - noteStringBuf = StringLoader::LoadLC( R_QTN_KEYG_CONF_KEYPAD_ACTIVE, - iEikonEnv ); - } - note->SetAnimation( R_QGN_NOTE_KEYGUARD_OPEN_ANIM ); - break; -/* case EFmTxOnNote: - { - const TInt KFrequencyMaxLength(7); - // read frequency - TInt frequencykHz = iSysApCenRepFmTxObserver->Frequency(); - TReal frequencyMHz = static_cast( frequencykHz ) / KCoefficientKhzToMhz; // kHz to Mhz - TBuf frequencyAsString; - frequencyAsString.AppendNum( frequencyMHz, TRealFormat( KFrequencyMaxLength, KDecimalsInMhzFrequency ) ); - AknTextUtils::LanguageSpecificNumberConversion( frequencyAsString ); - noteStringBuf - = StringLoader::LoadLC( R_QTN_FMTX_SYSAP_INFO_NOTE_CHANGE_FREQ, - frequencyAsString, - iEikonEnv ); - break; - } - case EFmTxAccessoryForbidsNote: - { - noteStringBuf = StringLoader::LoadLC( R_QTN_FMTX_SYSAP_INFO_NOTE_ACCESSORY_FORBIDS, - iEikonEnv ); - break; - } - case EFmTxAccessoryStandbyNote: - { - noteStringBuf = StringLoader::LoadLC( R_QTN_FMTX_SYSAP_INFO_NOTE_ACCESSORY_STANDBY, - iEikonEnv ); - break; - } - case EFmTxVolumeDisabledNote: - { - noteStringBuf = StringLoader::LoadLC( R_QTN_FMTX_SYSAP_INFO_NOTE_VOLUME_DISABLED, - iEikonEnv ); - break; - } - case EFmTxOffNote: - { - noteStringBuf = StringLoader::LoadLC( R_QTN_FMTX_SYSAP_INFO_NOTE_DISABLED, - iEikonEnv ); - break; - } -*/ case EPowerSaveModeActivated: - noteStringBuf = StringLoader::LoadLC( R_QTN_POWER_SAVING_ACTIVATED_CONF_NOTE, iEikonEnv ); - break; - case EPowerSaveModeDeactivated: - noteStringBuf = StringLoader::LoadLC( R_QTN_POWER_SAVING_DEACTIVATED_CONF_NOTE, iEikonEnv ); - break; - case ECannotActivatePowerSaveMode: - noteStringBuf = StringLoader::LoadLC( R_QTN_POWER_SAVING_FAILED_WARNING_NOTE, iEikonEnv ); - break; - case ECannotDeactivatePowerSaveMode: - noteStringBuf = StringLoader::LoadLC( R_QTN_POWER_SAVING_DEACTIVATION_FAILED_WARNING_NOTE, iEikonEnv ); - break; - default: - break; - } - - note->SetTone( tone ); - - // Set secondary display data if necessary -/* if ( iSysApFeatureManager->CoverDisplaySupported() && secondaryDisplayId != SecondaryDisplay::ECmdNoNote) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowUiNoteL - Notifying secondary display") ) ); - CAknSDData* sd; - - if ( aNote == EFmTxOnNote ) // frequency information is passed to secondary display - { - SecondaryDisplay::TFmTxFrequencyInKhzPckg pckg( iSysApCenRepFmTxObserver->Frequency() ); - sd = CAknSDData::NewL( SecondaryDisplay::KCatSysAp, secondaryDisplayId, pckg ); - } - else - { - sd = CAknSDData::NewL(SecondaryDisplay::KCatSysAp, secondaryDisplayId, KNullDesC8); - } - - note->SetSecondaryDisplayData(sd); // ownership to notifier client - } -*/ - if ( noteStringBuf ) - { - TPtr textBuffer = noteStringBuf->Des(); - TRACES( RDebug::Print( _L("CSysApAppUi::ShowUiNoteL Next:note->ShowNoteL" ) ) ); - note->ShowNoteL( noteType, textBuffer ); - CleanupStack::PopAndDestroy( ); // noteStringbuf - } - else - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowUiNoteL Next:note->ShowNoteL" ) ) ); - note->ShowNoteL( noteType, KNullDesC ); - } - } - else if( swState == ESwStateAlarm || swState == ESwStateCharging ) - { - if ( aNote != EUnplugChargerNote ) // don't play tone when charger is disconnected in charging state - { - static_cast(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( tone ); - } - } - - CleanupStack::PopAndDestroy(); // note + return err; } -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowChargingNoteL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShowChargingNoteL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL") ) ); - TBool showNote( ETrue ); - - TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); - TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL: swState: %d"), swState ) ); - - if( UiReady() || swState == ESwStateSecurityCheck ) - { - if ( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) == EPSCTsyCallStateRinging ) - { - showNote = EFalse; - } - TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL KCTsyCallState=%d"), StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ) ); - if ( showNote ) // Power Mgmt UI spec defines that no Charging note is shown while the phone is ringing/alerting - { - CAknGlobalNote* chargingNote = CAknGlobalNote::NewLC(); - chargingNote->SetTone( EAvkonSIDChargingBatteryTone ); - chargingNote->ShowNoteL( EAknGlobalChargingNote, KNullDesC ); - CleanupStack::PopAndDestroy( chargingNote ); - } - } - else if( swState == ESwStateAlarm || swState == ESwStateCharging ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL - Just play tone") ) ); - static_cast(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( EAvkonSIDChargingBatteryTone ); - } - else - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL - No note shown") ) ); - } - } // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleChargerNotesL() +// CSysApAppUi::ShowShutdownImageL // ---------------------------------------------------------------------------- -void CSysApAppUi::HandleChargerNotesL( const TInt aValue ) +// +void CSysApAppUi::ShowShutdownImageL( TInt aBitmapId ) { - TBool showNote(StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) != EPSCTsyCallStateRinging); - if ( aValue == EChargingStatusCharging ) - { - iSysApLightsController->BatteryEmptyL( EFalse ); - TRACES( RDebug::Print( _L("SysAp: charger connected") ) ); - iSysApLightsController->ChargerConnectedL( ETrue ); - ShowChargingNoteL(); - } - //Display Not Charging note - else if ( aValue == EChargingStatusError ) + TRACES( RDebug::Print(_L("CSysApAppUi::ShowShutdownImageL") ) ); + // do nothing + if ( !iSysApShutdownImage ) // Shutdown image may be shown without entering normal state (e.g. charging), so construct here { - if(showNote) - { - ShowUiNoteL( ENotChargingNote ); - } + TRACES( RDebug::Print( _L("CSysApAppUi::ShowShutdownImageL: trying CSysApShutdownImage::NewL()") ) ); + iSysApShutdownImage = CSysApShutdownImage::NewL(); } - else if ( aValue == EChargingStatusChargingComplete ) + TRACES( RDebug::Print( _L("CSysApAppUi::ShowShutdownImageL: trying CSysApShutdownImage::ShowShutdownImageL()") ) ); + iSysApShutdownImage->ShowShutdownImageL( aBitmapId ); + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::PrepareForShutdownImage() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::PrepareForShutdownImage() + { + TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownImage() START" ) ) ); + + // If RD_STARTUP_ANIMATION_CUSTOMIZATION is enabled, the following actions are always taken in PrepareForShutdownAnimation +#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION + if ( !iAnimationShowingTime ) // actions already taken in PrepareForShutdownAnimation { - iSysApLightsController->ChargingCompleteL(); + static_cast(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( EAvkonSIDPowerOffTone ); + CancelGlobalListQuery(); - TSysApNoteIds note( EBatteryFullNote ); - - if ( !iSysApUsbChargerDetector.HostOnlyUsbChargingUsed() && - iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) ) - { - note = EBatteryFullUnplugChargerNote; - } - iSysApUsbChargerDetector.Reset(); - if(showNote) + if ( iSysApPowerKeyMenuObserver ) { - ShowUiNoteL( note ); - } - } - else if ( aValue == EChargingStatusNotConnected ) - { - TRACES( RDebug::Print( _L("SysAp: charger removed") ) ); - iSysApLightsController->ChargerConnectedL( EFalse ); - - if ( !iSysApUsbChargerDetector.HostOnlyUsbChargingUsed() && - iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) ) - { - if(showNote) - { - ShowUiNoteL( EUnplugChargerNote ); - } + iSysApPowerKeyMenuObserver->Cancel(); } - iSysApUsbChargerDetector.Reset(); - } - else if ( aValue == EChargingStatusNotCharging ) - { - TRACES( RDebug::Print( _L("SysAp: Not charging") ) ); + + // deactivate notifiers before showing the shutdown image + AknNotifierController::CancelAllNotifications(); + AknNotifierController::HideAllNotifications(ETrue); + RWindowGroup groupWin = iCoeEnv->RootWin(); + iCapturedAppskey = groupWin.CaptureKey( EKeyApplication, KModifierMask, KModifierMask ); + iCapturedAppskeyUpAndDowns = groupWin.CaptureKeyUpAndDowns( EStdKeyApplication0, KModifierMask, KModifierMask ); } - else if ( aValue == EChargingStatusAlmostComplete ) - { - TRACES( RDebug::Print( _L("SysAp: Charging almost complete") ) ); - } - else if ( aValue == EChargingStatusChargingContinued ) - { - //in this case we simply want to scroll the battery bars and not turn light on or show ui note - // set lights controller iBatteryEmpty to EFalse - iSysApLightsController->BatteryEmptyL( EFalse ); - TRACES( RDebug::Print( _L("SysAp: charging continues") ) ); - } +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION + +#ifndef __SYSAP_MODULE_TEST //to make errors during shutdown sequence being seen more easily + iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront ); + TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownImage() Show Shutdown image" ) ) ); + ShowShutdownImage( 1 );//EMbmSysapQgn_startup_screen +#endif + TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownImage() END" ) ) ); } // ---------------------------------------------------------------------------- -// CSysApAppUi::ShowProfileNoteL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShowProfileNoteL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowProfileNoteL") ) ); - - if ( UiReady() ) - { - if ( iProfileNote ) - { - // when a call is coming in, there might be a pending "Selected profile" - // we don't want to show anymore - iProfileNote->CancelNoteL( iProfileNoteId ); - } - - TBufC profileName; - HBufC* noteStringBuf = NULL; - ActiveProfileNameL( profileName.Des() ); - noteStringBuf = StringLoader::LoadLC( R_TEXT_MODE_SELECTED, profileName, iEikonEnv ); - TPtr textBuffer = noteStringBuf->Des(); - AknTextUtils::DisplayTextLanguageSpecificNumberConversion( textBuffer ); - - // profile note is constructed when it is needed for the first time - if ( !iProfileNote ) - { - iProfileNote = CAknGlobalNote::NewL(); - iProfileNote->SetTone( EAvkonSIDConfirmationTone ); - } - - // Set secondary display data if necessary - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowProfileNoteL - Notifying secondary display") ) ); - SecondaryDisplay::TProfileName sdProfileName; - sdProfileName.Append(profileName.Left(SecondaryDisplay::KProfileNameMaxLen)); - SecondaryDisplay::TProfileNotePckg pckg(sdProfileName); - CAknSDData* sd = CAknSDData::NewL(SecondaryDisplay::KCatSysAp, SecondaryDisplay::ECmdShowProfileNote, pckg); - iProfileNote->SetSecondaryDisplayData(sd); // ownership to notifier client - } - - iProfileNoteId = iProfileNote->ShowNoteL( EAknGlobalConfirmationNote, textBuffer ); - - CleanupStack::PopAndDestroy( ); // noteStringbuf - - iSysApLightsController->ProfileChangedL(); // All notes should always turn lights on. - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowQueryL() +// CSysApAppUi::OkToInitiateShutdown() // ---------------------------------------------------------------------------- -void CSysApAppUi::ShowQueryL( const TSysApConfirmationQueryIds aQueryId, const TDesC& aValue ) +TBool CSysApAppUi::OkToInitiateShutdown() { - CancelGlobalListQuery(); + TInt swState; + RProperty::Get( KPSUidStartup, KPSGlobalSystemState, swState ); - if ( aQueryId == ESysApRestartPhoneQuery ) - { - iDisablePowerkeyMenu = ETrue; - // Cancel any other query that might be outstanding (i.e. ESysApRemoveMmcNote), - // to avoid multiple overlapping queries causing problems - if ( iSysApConfirmationQuery ) - { - iSysApConfirmationQuery->Cancel(); - } - - if ( !iSysApConfirmationQueryForRestart ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowQueryL: trying CSysApConfirmationQuery::NewL() for restart") ) ); - iSysApConfirmationQueryForRestart = CSysApConfirmationQuery::NewL( *this ); - } - - iSysApConfirmationQueryForRestart->ShowQueryL( aQueryId, iEikonEnv ); - } - else + if( !iShutdownStarted && + swState == ESwStateStartingCriticalApps || + swState == ESwStateSelfTestOK || + swState == ESwStateSecurityCheck || + swState == ESwStateCriticalPhaseOK || + swState == ESwStateEmergencyCallsOnly || + swState == ESwStateCharging || + swState == ESwStateAlarm || + swState == ESwStateNormalRfOn || + swState == ESwStateNormalRfOff || + swState == ESwStateNormalBTSap || + swState == ESwStateFatalStartupError ) { - if ( !iSysApConfirmationQuery ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowQueryL: trying CSysApConfirmationQuery::NewL()") ) ); - iSysApConfirmationQuery = CSysApConfirmationQuery::NewL( *this ); - } - - iSysApConfirmationQuery->ShowQueryL( aQueryId, aValue, iEikonEnv ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UpdateBatteryBarsL( const TInt aState ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::UpdateBatteryBarsL( const TInt aState ) - { - TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) ); - TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL aState: %d, chargerState:%d"), aState, state ) ); - HandleUsbCharger( state ); - if( state == EChargingStatusCharging || - state == EChargingStatusChargingContinued || - state == EChargingStatusAlmostComplete ) - { - if ( !iCharging ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL: Starting Charging") ) ); - iBatteryNotify->StartChargingL(); - iCharging = ETrue; - } - - // When Avkon supports battery state sending while charging, - // add setting battery level here also. + iShutdownStarted = ETrue; + return ETrue; } else { - if ( iCharging ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL: Stopping Charging") ) ); - iBatteryNotify->StopChargingL(); - iCharging = EFalse; - } - - if( state == KErrUnknown || aState == KErrUnknown ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL: CAknBatteryNotify::SetBatteryLevelL(0)") ) ); - iBatteryNotify->SetBatteryLevelL( 0 ); - } - else - { - TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL: CAknBatteryNotify::SetBatteryLevelL(%d)"), aState - EBatteryLevelLevel0 ) ); - iBatteryNotify->SetBatteryLevelL( aState - EBatteryLevelLevel0 ); - } - } - - if ( !iSysApPsmController ) // created here if first state change has not occurred yet - { - iSysApPsmController = CSysApPsmController::NewL( *this ); - } - - if ( iSysApPsmController ) - { - if ( iSysApPsmController->FullPsmEnabled() ) - { - iBatteryNotify->SetBatteryStateL( EAknBatteryIndicatorPowerSave ); - } - else - { - iBatteryNotify->SetBatteryStateL( EAknBatteryIndicatorNormal ); - } - } - - if ( iSysApBatteryInfoController ) - { - iSysApBatteryInfoController->BatteryLevelUpdatedL(); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UpdateSignalBarsL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::UpdateSignalBarsL() - { - UpdateSignalBarsL(iSysApEtelConnector->GetSignalBars()); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UpdateSignalBarsL( const TInt aState ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::UpdateSignalBarsL( const TInt aState ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::UpdateSignalBarsL aState: %d"), aState ) ); - - if( aState == KAknSignalOffLineMode || (iSysApOfflineModeController->OfflineModeActive() && !iEmergencyCallActive) ) - { - iSignalNotify->SetSignalLevelL( KAknSignalOffLineMode ); - } - else if( aState <= 0 ) - { - // Do not update indicator show zero bars if we should be showing X over bars - // This is required for indicator to work correctly in BT SAP mode. - // Cannot use check for BT SAP enabled status, as zero bars notify comes before enabled status changes. - if ( !iIgnoreZeroNetworkBarNotifications ) - { - iSignalNotify->SetSignalLevelL( 0 ); - } - } - else - { - iSignalNotify->SetSignalLevelL( aState ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetSignalIndicatorL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::SetSignalIndicatorL() - { - TSysApNetworkMode networkMode( ESysApGSM ); - - TInt networkModeFromNetworkInfo( StateOfProperty( KPSUidNetworkInfo, KNWTelephonyNetworkMode ) ); - if ( networkModeFromNetworkInfo == ENWNetworkModeWcdma ) - { - networkMode = ESysApWCDMA; - } - else - { - networkMode = ESysApGSM; - } - - TRACES( RDebug::Print( _L("CSysApAppUi::SetSignalIndicatorL: networkMode = %d" ), networkMode ) ); - - if( iSysApOfflineModeController->OfflineModeActive() && !iEmergencyCallActive ) - { - // The device is in Offline Mode - if ( iSysApFeatureManager->Supported( KSysApFeatureIdGprs_G_Icon ) ) - { - iSignalNotify->SetGprsStateL( EAknSignalGprsIndicatorOff ); - } - else - { - iSignalNotify->SetCommonPacketDataStateL( EAknSignalCommonPacketDataIndicatorOff ); - } - iSignalNotify->SetWcdmaStateL( EAknSignalWcdmaIndicatorOff ); - iSignalNotify->SetHsdpaStateL( EAknSignalHsdpaIndicatorOff); - } - else - { - // The device is in Online Mode - switch ( networkMode ) - { - case ESysApGSM: - SetSignalIndicatorGsmL(); - break; - - case ESysApWCDMA: - SetSignalIndicatorWcdmaL(); - break; - - default: - break; - } + return EFalse; } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetSignalIndicatorGsmL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::SetSignalIndicatorGsmL() + +void CSysApAppUi::PopupNote() { - TInt signalGprsIndicatorState( 0 ); - TInt signalIndicatorState( 0 ); - TInt bearerValue = EBearerUnknown; - - if(iSysApConnectionMonitorObserver) - { - bearerValue = iSysApConnectionMonitorObserver->GetBearerValue(); - } - - if(bearerValue == EBearerEdgeGPRS) - { - TInt egprsStatus = StateOfProperty( KUidSystemCategory, KPSUidGprsStatusValue ); - TRACES( RDebug::Print( _L("CSysApAppUi::SetSignalIndicatorGsmL gprsStatus: %d" ), egprsStatus ) ); - iSignalNotify->SetWcdmaStateL( EAknSignalWcdmaIndicatorOff ); - iSignalNotify->SetHsdpaStateL( EAknSignalHsdpaIndicatorOff ); - switch ( egprsStatus ) - { - case EPSGprsContextActive: - signalGprsIndicatorState = EAknSignalEdgeIndicatorContext; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorContext; - iGprsActivated = ETrue; - iGprsSuspended = EFalse; - HandleGprsNotesL(); - break; - - case EPSGprsContextActivating: - signalGprsIndicatorState = EAknSignalEdgeIndicatorEstablishingContext; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorEstablishingContext; - iGprsActivated = EFalse; - iGprsSuspended = EFalse; - break; - - case EPSGprsSuspend: - signalGprsIndicatorState = EAknSignalEdgeIndicatorSuspended; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorSuspended; - iGprsSuspended = ETrue; - HandleGprsNotesL(); - break; - - case EPSGprsAttach: - signalGprsIndicatorState = EAknSignalEdgeIndicatorAttached; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorAttached; - iGprsActivated = EFalse; - iGprsSuspended = EFalse; - break; - - case EPSGprsMultibleContextActive: - signalGprsIndicatorState = EAknSignalEdgeIndicatorMultipdp; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorMultipdp; - iGprsActivated = ETrue; - iGprsSuspended = EFalse; - HandleGprsNotesL(); - break; - - case EPSGprsUnattached: - default: - signalGprsIndicatorState = EAknSignalEdgeIndicatorOff; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorOff; - iGprsSuspendedNoteShown = EFalse; - iGprsActivated = EFalse; - iGprsSuspended = EFalse; - iCallActivated = EFalse; - break; - } - } - else - { - - TInt gprsStatus = StateOfProperty( KUidSystemCategory, KPSUidGprsStatusValue ); - TRACES( RDebug::Print( _L("CSysApAppUi::SetSignalIndicatorGsmL gprsStatus: %d" ), gprsStatus ) ); - iSignalNotify->SetWcdmaStateL( EAknSignalWcdmaIndicatorOff ); - iSignalNotify->SetHsdpaStateL( EAknSignalHsdpaIndicatorOff ); - switch ( gprsStatus ) - { - case EPSGprsContextActive: - signalGprsIndicatorState = EAknSignalGprsIndicatorContext; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorContext; - iGprsActivated = ETrue; - iGprsSuspended = EFalse; - HandleGprsNotesL(); - break; - - case EPSGprsContextActivating: - signalGprsIndicatorState = EAknSignalGprsIndicatorEstablishingContext; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorEstablishingContext; - iGprsActivated = EFalse; - iGprsSuspended = EFalse; - break; - - case EPSGprsSuspend: - signalGprsIndicatorState = EAknSignalGprsIndicatorSuspended; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorSuspended; - iGprsSuspended = ETrue; - HandleGprsNotesL(); - break; - - case EPSGprsAttach: - signalGprsIndicatorState = EAknSignalGprsIndicatorAttached; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorAttached; - iGprsActivated = EFalse; - iGprsSuspended = EFalse; - break; - - case EPSGprsMultibleContextActive: - signalGprsIndicatorState = EAknSignalGprsIndicatorMultipdp; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorMultipdp; - iGprsActivated = ETrue; - iGprsSuspended = EFalse; - HandleGprsNotesL(); - break; - - case EPSGprsUnattached: - default: - signalGprsIndicatorState = EAknSignalGprsIndicatorOff; - signalIndicatorState = EAknSignalCommonPacketDataIndicatorOff; - iGprsSuspendedNoteShown = EFalse; - iGprsActivated = EFalse; - iGprsSuspended = EFalse; - iCallActivated = EFalse; - break; - } - } - - if(bearerValue == EBearerEdgeGPRS) //EdgeGPRS connection - { - if( iSysApFeatureManager->Supported( KSysApFeatureIdUseEdgeGPRSIcon ) ) - { - iSignalNotify->SetEdgeStateL( signalGprsIndicatorState ); - } - else - { - iSignalNotify->SetCommonPacketDataStateL( signalIndicatorState ); - } - } - else - { - - if ( iSysApFeatureManager->Supported( KSysApFeatureIdGprs_G_Icon ) ) - { - iSignalNotify->SetGprsStateL( signalGprsIndicatorState ); - } - else - { - TRACES( RDebug::Print( _L("CSysApAppUi::SetSignalIndicatorGsmL SetCommonPacketDataStateL( %d )" ), signalIndicatorState ) ); - iSignalNotify->SetCommonPacketDataStateL( signalIndicatorState ); - } - } + iIgnoreNextPowerKeyUpEvent = ETrue; + // TRACES( RDebug::Print( _L("CSysApAppUi::Key was consumed") ) ); + _LIT(KPowerPressKey,"Short power key"); + HBufC* aString = HBufC16::NewLC(50); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString } -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetSignalIndicatorWcdmaL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::SetSignalIndicatorWcdmaL() - { - TInt wcdmaStatus; - wcdmaStatus = StateOfProperty( KUidSystemCategory, KPSUidWcdmaStatusValue ); - TRACES( RDebug::Print( _L("CSysApAppUi::SetSignalIndicatorWcdmaL: wcdmaStatus: %d" ), wcdmaStatus ) ); - if ( iSysApFeatureManager->Supported( KSysApFeatureIdGprs_G_Icon ) ) - { - iSignalNotify->SetGprsStateL( EAknSignalGprsIndicatorOff ); - } - else - { - iSignalNotify->SetCommonPacketDataStateL( EAknSignalCommonPacketDataIndicatorOff ); - } +// ---------------------------------------------------------------------------- +// CSysApAppUi::SetUsbAttachStatus +// ---------------------------------------------------------------------------- +#ifndef RD_MULTIPLE_DRIVE +void CSysApAppUi::SetUsbAttachStatus( const TBool aUsbAttached ) + { + // Prevent double beep when USB file transfer gets activated but + // allow MMC inserted beep when: + // a) USB file transfer is active + // b) MMC is not inserted when USB cable is attached + iHideNextBeep = ( iMMCInserted && aUsbAttached ); + } +#else // RD_MULTIPLE_DRIVE +void CSysApAppUi::SetUsbAttachStatus( const TBool aUsbAttached ) + { + TRACES( RDebug::Print( + _L( "CSysApAppUi::SetUsbAttachStatus: aUsbAttached: %d" ), + aUsbAttached ) ); - TInt signalWcdmaIndicatorState; - TInt signalHsdpaIndicatorState; - - switch ( wcdmaStatus ) + if ( aUsbAttached ) { - case EPSWcdmaContextActive: - signalWcdmaIndicatorState = EAknSignalWcdmaIndicatorContext; - signalHsdpaIndicatorState = EAknSignalHsdpaIndicatorContext; - break; - case EPSWcdmaContextActivating: - signalWcdmaIndicatorState = EAknSignalWcdmaIndicatorEstablishingContext; - signalHsdpaIndicatorState = EAknSignalHsdpaIndicatorEstablishingContext; - break; - case EPSWcdmaSuspend: - signalWcdmaIndicatorState = EAknSignalWcdmaIndicatorSuspended; - signalHsdpaIndicatorState = EAknSignalHsdpaIndicatorSuspended; - break; - case EPSWcdmaAttach: - signalWcdmaIndicatorState = EAknSignalWcdmaIndicatorAttached; - signalHsdpaIndicatorState = EAknSignalHsdpaIndicatorAttached; - break; - case EPSWcdmaMultipleContextActive: - signalWcdmaIndicatorState = EAknSignalWcdmaIndicatorMultipdp; - signalHsdpaIndicatorState = EAknSignalHsdpaIndicatorMultipdp; - break; - case EPSWcdmaUnattached: - default: - signalWcdmaIndicatorState = EAknSignalWcdmaIndicatorAvailable; - signalHsdpaIndicatorState = EAknSignalHsdpaIndicatorAvailable; - break; + // For ignoring extra beeps caused by USB file transfer +/* iSysApDriveList->ResetDrivesInsertBeepIgnored(); + iSysApDriveList->MarkDrivesInsertBeepIgnored( iInsertedMemoryCards ); + // Will take care in next sub +*/ } + } +#endif // RD_MULTIPLE_DRIVE + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::UsbChargerDetector +// ---------------------------------------------------------------------------- +// +TSysApUsbChargerDetector& CSysApAppUi::UsbChargerDetector() + { + return iSysApUsbChargerDetector; + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleAccessoryDisconnectedL() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleAccessoryDisconnectedL() + { + TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryDisconnectedL()" ) ) ); + + + TAccMode accessoryState(EAccModeHandPortable); + if ( iSysApAccessoryObserver ) + { + accessoryState = iSysApAccessoryObserver->GetAccessoryMode(); } - TBool showHsdpaAvailable = EFalse; - - if ( iSysApFeatureManager->Supported( KSysApFeatureIdUseHsdpaAvailableIcon ) ) + if ( accessoryState == EAccModeHandPortable ) { - // HSDPA Resource Availability information is a configurable feature. - showHsdpaAvailable = iSysApEtelConnector->HsdpaAvailable(); + iSysApLightsController->AccessoryConnectedL( EFalse ); + iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected, 0 ); } - - TBool isHsdpaBearer = iSysApEtelConnector->IsBearerHsdpa(); - - TRACES( RDebug::Print( _L("CSysApAppUi::SetSignalIndicatorWcdmaL: isHdpaBearer=%d, showHsdpaAvailable=%d" ), - isHsdpaBearer, showHsdpaAvailable ) ); - - if ( isHsdpaBearer || showHsdpaAvailable ) - { - iSignalNotify->SetWcdmaStateL( EAknSignalWcdmaIndicatorOff ); - iSignalNotify->SetHsdpaStateL( signalHsdpaIndicatorState ); - } - else - { - iSignalNotify->SetHsdpaStateL( EAknSignalHsdpaIndicatorOff ); - iSignalNotify->SetWcdmaStateL( signalWcdmaIndicatorState ); - } - } + + SetIhfIndicatorL(); + SetHacIndicatorL(); -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleGprsNotesL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleGprsNotesL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleGprsNotesL" ) ) ); - if ( iSysApFeatureManager->Supported( KSysApFeatureIdGPRSNotes ) ) + // If lock disabled because of accessory, reactivate it, unless phone call or alarm is ongoing + if ( iKeyLockOnBeforeCradle ) { - // In WCDMA system, receiving or making calls has no effect to the possibly - // existing PDP contexts i.e. GPRS notes are not needed. - TInt networkMode = StateOfProperty( KPSUidNetworkInfo, KNWTelephonyNetworkMode ); - TRACES( RDebug::Print( _L("CSysApAppUi::HandleGprsNotesL: networkMode %d" ), networkMode ) ); - if ( networkMode != ENWNetworkModeWcdma ) + iKeyLockOnBeforeCradle = EFalse; + if ( !iKeyLockOnBeforeCall && !iKeyLockOnBeforeAlarm ) { - if ( iGprsActivated && iGprsSuspended && iCallActivated && !iGprsSuspendedNoteShown ) + if ( !iDeviceLockEnabled ) { - StartGprsSuspendedTimer(); + iKeyguardController->EnableKeyguard(ETrue); } - else if ( iGprsSuspendedNoteShown && !iGprsSuspended ) + else { - ShowUiNoteL( EGprsResumedNote ); - iGprsSuspendedNoteShown = EFalse; - iGprsSuspended = EFalse; - iCallActivated = EFalse; + iKeyguardController->EnableKeyguard(EFalse); } } } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetIndicatorStateL( TInt aIndicator, TInt aState ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::SetIndicatorStateL( const TInt aIndicator, const TInt aState ) const - { - CAknSmallIndicator* theIndicator = CAknSmallIndicator::NewLC( TUid::Uid( aIndicator ) ); - theIndicator->SetIndicatorStateL( aState ); - CleanupStack::PopAndDestroy(); //theIndicator - } // ---------------------------------------------------------------------------- -// CSysApAppUi::GoOnlineL() +// CSysApAppUi::HandleAccessoryConnectedL() // ---------------------------------------------------------------------------- -void CSysApAppUi::GoOnlineL( TBool aDoProfileChange ) +void CSysApAppUi::HandleAccessoryConnectedL( TAccMode aAccessoryState ) { - if ( iSysApFeatureManager->OfflineModeSupported() ) + TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryConnectedL( aAccessoryState: %d ) "), aAccessoryState ) ); + + if ( aAccessoryState == EAccModeWirelessHeadset || + aAccessoryState == EAccModeWiredHeadset || + aAccessoryState == EAccModeHeadphones ) + { + } + else if ( aAccessoryState == EAccModeLoopset ) + { + } + else if ( aAccessoryState == EAccModeTextDevice ) { - TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: going from off-line into on-line: aDoProfileChange=%d" ), aDoProfileChange ) ); - // in case profile change is not needed, event handling for subsequent profile changes are must be allowed - iHandleNextProfileEvent = !aDoProfileChange; - iActivateBt = iSysApOfflineModeController->MustBtBeActivated(); + } + else if ( aAccessoryState == EAccModeWirelessCarKit || aAccessoryState == EAccModeWiredCarKit ) + { + } + else if ( aAccessoryState == EAccModeTVOut ) + { + } + else if (aAccessoryState == EAccModeHDMI ) + { + } + + TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); + TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryConnectedL: swState: %d"), swState ) ); + + if( UiReady() || swState == ESwStateSecurityCheck ) + { + iSysApLightsController->AccessoryConnectedL( ETrue ); + } - if ( aDoProfileChange ) + if ( ( ! iSysApOfflineModeController->OfflineModeActive() )) + { + if ( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected ) < 1 ) + // accessory not connected already + { + iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected, 1 ); + } + } + + // Carkit and music stand have also light on permanently option that needs to be checked + if( aAccessoryState == EAccModeWiredCarKit || aAccessoryState == EAccModeMusicStand ) + { + // When device is placed on a handsfree cradle, keyguard must be disabled (unless device is locked) + // Note: It is assumed that if carkit/music stand is connected, the phone is in the cradle. + if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCall || iKeyLockOnBeforeAlarm ) { - TRAPD( err, ActivateProfileL( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileBeforeOfflineMode ) ) ); - if ( err == KErrNotFound ) + iKeyLockOnBeforeCradle = ETrue; + + if ( iKeyLockEnabled && !iDeviceLockEnabled ) { - // Activate general profile instead, if previously used profile was not found - TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: Previously used profile was not found, restoring to general profile" ) ) ); - ActivateProfileL(KGeneralProfileId); + iKeyguardController->DisableKeyguard(EFalse); + } + } + } + SetIhfIndicatorL(); + SetHacIndicatorL(); + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::SetHacIndicatorL() +// ---------------------------------------------------------------------------- +void CSysApAppUi::SetHacIndicatorL() + { + + if ( !iSysApCenRepHacSettingObserver ) + { + // Do nothing if HAC setting observer has not been created yet + // This occurs in case some party is trying to set HAC indicator during + // ConstructL(), e.g. when switching from offline to online during startup + TRACES( RDebug::Print( _L("CSysApAppUi::SetHacIndicatorL: do nothing, HAC observer does not exist yet") ) ); + return; + } + + if ( iSysApCenRepHacSettingObserver->HacMode() ) + { + TBool accessoryConnected ( EFalse ); + + TAccMode accMode(EAccModeHandPortable); + + if ( iSysApAccessoryObserver ) + { + accMode = iSysApAccessoryObserver->GetAccessoryMode(); + + if ( accMode != EAccModeHandPortable ) + { + accessoryConnected = ETrue; } } - iSysApOfflineModeController->SwitchFromOfflineToOnlineModeL(); - TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: iActivateBt = %d" ), iActivateBt ) ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::GoOfflineL() -// ---------------------------------------------------------------------------- +// TInt indicatorState = EAknIndicatorStateOn; -void CSysApAppUi::GoOfflineL() - { - if ( iSysApFeatureManager->OfflineModeSupported() ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::GoOfflineL" ) ) ); - iHandleNextProfileEvent = EFalse; - iDeactivateBt = ETrue; - ActivateProfileL( KOfflineModeProfileId ); - iSysApOfflineModeController->SwitchFromOnlineToOfflineModeL(); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SwitchFromOnlineToOfflineModeL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::SwitchFromOnlineToOfflineModeL() - { -/* if ( iSysApFeatureManager->FmTxSupported() ) - { - TFmTxState state = static_cast(StateOfProperty( KPSUidHWRMFmTx, KHWRMFmTxStatus )); - switch ( state ) + if ( !accessoryConnected ) // When accessory is not connected, check offline and call state { - case EFmTxStateActive: - case EFmTxStateInactive: - case EFmTxStateScanning: - ShowQueryL( ESysApUseFmTxInOfflineQuery ); // show "use fm tx in offline?" if FM TX is on - break; - - default: - // do nothing - break; - } - } -*/ iSysApOfflineModeController->SwitchFromOnlineToOfflineModeL(); - } + if ( OfflineModeActive() ) // HAC indicator is not shown in offline mode + { + // indicatorState = EAknIndicatorStateOff; + } + else + { + // during active call with IHF activated HAC indicator is not shown + TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ); + if ( callState < KErrNone ) + { + callState = EPSCTsyCallStateNone; + } -// ---------------------------------------------------------------------------- -// CSysApAppUi::OfflineModeChangedL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::OfflineModeChangedL() - { -#ifdef SYSAP_USE_STARTUP_UI_PHASE - // if UI is not ready, don't update indicators - if ( !UiReady() ) - { - return; - } -#endif // SYSAP_USE_STARTUP_UI_PHASE - - // Update network bar indicator - if ( OfflineModeActive() ) - { - UpdateSignalBarsL( KAknSignalOffLineMode ); + if ( callState != EPSCTsyCallStateNone && IhfEnabledL() ) + { + // indicatorState = EAknIndicatorStateOff; + } + } + + } + else + { + // If an accessory is connected, HAC indicator should not be shown +// indicatorState = EAknIndicatorStateOff; + } + + // SetIndicatorStateL( EAknIndicatorHAC, indicatorState ); + } else { - UpdateSignalBarsL(); - } - - // Update network mode indicator - SetSignalIndicatorL(); - - // Update HAC indicator - SetHacIndicatorL(); + // If HAC is not active, always disable indicator regardless of accessory state + // SetIndicatorStateL( EAknIndicatorHAC, EAknIndicatorStateOff ); + } + + } -// ---------------------------------------------------------------------------- -// CSysApAppUi::OfflineModeActive() -// ---------------------------------------------------------------------------- -TBool CSysApAppUi::OfflineModeActive() - { - return iSysApOfflineModeController->OfflineModeActive(); - } // ---------------------------------------------------------------------------- // CSysApAppUi::DoNotActivateBt() @@ -2258,57 +1375,23 @@ iSysApOfflineModeController->DoNotActivateBt(); } -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetBtPowerState() -// ---------------------------------------------------------------------------- -TInt CSysApAppUi::SetBtPowerState( TBool aBtState ) - { - if ( iSysApBtController ) - { - return iSysApBtController->SetPowerState( aBtState ); - } - else - { - return KErrNotReady; - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::KeyLockState() const -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::KeyLockState() const - { - return iKeyLockEnabled; - } // ---------------------------------------------------------------------------- -// CSysApAppUi::DeviceLockState() const +// CSysApAppUi::IhfEnabledL // ---------------------------------------------------------------------------- -TBool CSysApAppUi::DeviceLockState() const - { - return iDeviceLockEnabled; - } -/* -// ---------------------------------------------------------------------------- -// CSysApAppUi::ChangeFmTxStateL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::ChangeFmTxStateL( TBool aEnable ) +TBool CSysApAppUi::IhfEnabledL() { - // disable fm transmission - CHWRMFmTx* fmtx = CHWRMFmTx::NewLC(); - if ( aEnable ) - { - fmtx->EnableL(); - } - else - { - fmtx->DisableL(); - } - CleanupStack::PopAndDestroy( fmtx ); - } -*/ + TRACES( RDebug::Print( _L("CSysApAppUi::IhfEnabledL(): iSysApAudioRoutingObserver=0x%x"), iSysApAudioRoutingObserver ) ); + + if ( !iSysApAudioRoutingObserver ) // create observer if needed + { + iSysApAudioRoutingObserver = CSysApAudioRoutingObserver::NewL( *this ); + } + + return iSysApAudioRoutingObserver->IhfEnabled(); + } + // ---------------------------------------------------------------------------- // CSysApAppUi::SetIhfIndicatorL() @@ -2334,786 +1417,100 @@ if( (callState != EPSCTsyCallStateNone && IhfEnabledL() && !accessoryConnected) || accMode == EAccModeMusicStand ) // Music stand always shows IHF indicator { - SetIndicatorStateL( EAknIndicatorIHFActive, EAknIndicatorStateOn ); - if ( accMode == EAccModeMusicStand ) { - // hide other accessory indicators to prevent displaying of duplicate icons in some cases - // e.g. when wireless hf is connected - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); + // do nothing } } else { - SetIndicatorStateL( EAknIndicatorIHFActive, EAknIndicatorStateOff ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleSmsStorageNotificationL( TBool aSimStoreFull ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleSmsStorageNotificationL( TBool aSimStoreFull ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleSmsStorageNotificationL: aSimStoreFull: %d "), aSimStoreFull ) ); - - if ( aSimStoreFull ) - { - HBufC* noteStringBuf; - noteStringBuf = StringLoader::LoadLC( R_QTN_MEMLO_MEMORY_LOW_SIM_MES, iEikonEnv ); - TPtr textBuffer = noteStringBuf->Des(); - iSysApMsgSimMemLowQuery->StartL( textBuffer ); - CleanupStack::PopAndDestroy(); - } - - SetEnvelopeIndicatorL(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleNspsRawKeyEventL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleNspsRawKeyEventL() - { -#ifdef __SYSAP_MODULE_TEST - ModuleTestShowUiNoteL( _L("Network wakeup from NSPS") ); -#endif - - if ( iSysApEtelConnector ) - { - iSysApEtelConnector->CommandNetCsWakeupOnNsps(); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleNetworkNspsNotification( RMmCustomAPI::TNspsStatus aNspsStatus ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleNetworkNspsNotification( RMmCustomAPI::TNspsStatus aNspsStatus ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleNetworkNspsNotification aNspsStatus:%d, iNsps:%d )" ), aNspsStatus, iNsps ) ); - if( iSysApNspsHandler ) - { - if( aNspsStatus == RMmCustomAPI::ENspsOn ) - { - if( !iNsps ) - { -#ifdef __SYSAP_MODULE_TEST - TRAPD( err, ModuleTestShowUiNoteL( _L("Setting NSPS on") ) ); -#endif - iSysApNspsHandler->SetNspsOn(); - iNsps = ETrue; - } - } - else if( aNspsStatus == RMmCustomAPI::ENspsOff ) - { - if( iNsps ) - { -#ifdef __SYSAP_MODULE_TEST - TRAPD( err, ModuleTestShowUiNoteL( _L("Setting NSPS off") ) ); -#endif - iSysApNspsHandler->SetNspsOff(); - iNsps = EFalse; - } - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleMessageTonePlayingQuitability( TInt aTonePlayingStatus ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleMessageTonePlayingQuitability( TInt aTonePlayingStatus ) - { - if( iSysApNspsHandler ) - { - if( aTonePlayingStatus == ECoreAppUIsStopTonePlaying ) - { - iSysApNspsHandler->SetMessageToneNotPlaying(); - } - else if( aTonePlayingStatus == ECoreAppUIsTonePlaying ) - { - iSysApNspsHandler->SetMessageTonePlaying(); - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ActivateKeyeventForwardingForLights() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ActivateKeyeventForwardingForLights(TBool aActivate) - { - if( iSysApNspsHandler ) - { - if ( aActivate ) - { - iSysApNspsHandler->ActivateKeyeventForwardingForLights(); - } - else - { - iSysApNspsHandler->DeActivateKeyeventForwardingForLights(); - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::StartShutDownTimerOnAlarmAndChargingStates() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::StartShutDownTimerOnAlarmAndChargingStates() - { - if( !iAlarmOrChargingStateShutdownStarted ) - { - if ( !iTimer ) - { - TRAPD( err, iTimer = CPeriodic::NewL( EPriorityNormal ) ); - - if ( err != KErrNone ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::StartShutDownTimerOnAlarmAndChargingStates: CPeriodic::NewL failed: %d"), err ) ); - return; - } - } - iTimer->Cancel(); - iTimer->Start( KDelayBeforeShuttingDownInAlarmAndChargingStates, - KDelayBeforeShuttingDownInAlarmAndChargingStates, - TCallBack( DoShutdownOnAlarmStateAfterCallBack, this ) ); - iAlarmOrChargingStateShutdownStarted = ETrue; - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoShutdownOnAlarmStateAfterCallBack( TAny* aObject ) -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::DoShutdownOnAlarmStateAfterCallBack( TAny* aObject ) - { - CSysApAppUi* appUi = STATIC_CAST( CSysApAppUi*, aObject ); - - if ( appUi->iTimer ) - { - appUi->iTimer->Cancel(); - } - - TRAP_IGNORE( appUi->DoShutdownL( EFalse, KDummyReason ) ); - - return KErrNone; - } - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION -// ---------------------------------------------------------------------------- -// CSysApAppUi::StartAnimTiming() -// ---------------------------------------------------------------------------- -void CSysApAppUi::StartAnimTiming() - { - TRACES( RDebug::Print( _L("CSysApAppUi::StartAnimTiming() Start animation timer, time %d ms" ), iAnimationShowingTime ) ); - - if ( !iAnimTimer ) - { - TRAPD( err, iAnimTimer = CPeriodic::NewL( EPriorityNormal ) ); - - if ( err != KErrNone ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::StartAnimTiming() CPeriodic::NewL failed %d " ), err ) ); - return; - } - } - - iAnimTimer->Start( - iAnimationShowingTime*KCoefficientToMakeMicroToMilliSeconds, - iAnimationShowingTime*KCoefficientToMakeMicroToMilliSeconds, - TCallBack( DoStopAnimTiming, this ) ); - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoStopAnimTiming( TAny* aObject ) -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::DoStopAnimTiming( TAny* aObject ) - { - TInt err(KErrNone); - CSysApAppUi* appUi = STATIC_CAST( CSysApAppUi*, aObject ); - - // This method could theoretically be called by two timers (iAnimTimer and one in CSysApShutdownAnimation), - // so a check is needed to prevent multiple executions. - if ( !(appUi->iShutdownContinued) ) - { - appUi->iShutdownContinued = ETrue; - - TRACES( RDebug::Print( _L("CSysApAppUi::DoStopAnimTiming() Animation timer completed or animation skipped" ) ) ); - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - if ( appUi->iAnimTimer ) - { - appUi->iAnimTimer->Cancel(); - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - if ( appUi->iTimer ) - { - appUi->iTimer->Cancel(); - } - - TRACES( RDebug::Print( _L("CSysApAppUi::DoStopAnimTiming() Call ContinueShutdown(...)" ) ) ); - appUi->ContinueShutdown(); - TRACES( RDebug::Print( _L("CSysApAppUi::DoStopAnimTiming() end") ) ); - } - - return err; - } - - -// ---------------------------------------------------------------------------- -// CSysApAppUi::StartGprsSuspendedTimer() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::StartGprsSuspendedTimer() - { - TRACES( RDebug::Print( _L("CSysApAppUi::StartGprsSuspendedTimer()") ) ); - if( !iAlarmOrChargingStateShutdownStarted ) // not relevant if shutting down - { - if ( !iTimer ) - { - TRAPD( err, iTimer = CPeriodic::NewL( EPriorityNormal ) ); - - if ( err != KErrNone ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::StartGprsSuspendedTimer: CPeriodic::NewL failed: %d"), err ) ); - return; - } - } - - iTimer->Cancel(); - iTimer->Start( KDelayBeforeShowingGprsSuspendedNote, - KDelayBeforeShowingGprsSuspendedNote, - TCallBack( ShowGprsSuspendedNoteAfterCallBack, this ) ); + // do nothing } } // ---------------------------------------------------------------------------- -// CSysApAppUi::ShowGprsSuspendedNoteAfterCallBack( TAny* aObject ) +// CSysApAppUi::DoLightsTimeoutChangedL // ---------------------------------------------------------------------------- - -TInt CSysApAppUi::ShowGprsSuspendedNoteAfterCallBack( TAny* aObject ) +void CSysApAppUi::DoLightsTimeoutChangedL( const TInt aTimeout ) { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowGprsSuspendedNoteAfterCallBack") ) ); - - CSysApAppUi* appUi = STATIC_CAST( CSysApAppUi*, aObject ); - - if ( appUi->iTimer ) - { - appUi->iTimer->Cancel(); - } - - // Note is needed if call is still active and used network is not WCDMA - TInt callType = appUi->StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallType ); - TInt networkMode = appUi->StateOfProperty( KPSUidNetworkInfo, KNWTelephonyNetworkMode ); - TRACES( RDebug::Print( - _L("CSysApAppUi::ShowGprsSuspendedNoteAfterCallBack: callType %d networkMode %d"), - callType, networkMode ) ); - if ( EPSCTsyCallTypeCSVoice == callType && ENWNetworkModeWcdma != networkMode ) - { - appUi->iGprsSuspendedNoteShown = ETrue; - TRAP_IGNORE( appUi->ShowUiNoteL( EGprsSuspendedNote ) ); - } - return KErrNone; + iSysApLightsController->DoLightsTimeoutChangedL( aTimeout ); } + // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleAccessoryConnectedL() +// CSysApAppUi::DoSwStateNormalConstructionL() // ---------------------------------------------------------------------------- -void CSysApAppUi::HandleAccessoryConnectedL( TAccMode aAccessoryState ) +void CSysApAppUi::DoSwStateNormalConstructionL() { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryConnectedL( aAccessoryState: %d ) "), aAccessoryState ) ); + // Let's ensure that the lights will remain on for 15 secs after sw state normal + User::ResetInactivityTime(); - if ( aAccessoryState == EAccModeWirelessHeadset || - aAccessoryState == EAccModeWiredHeadset || - aAccessoryState == EAccModeHeadphones ) - { - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if ( aAccessoryState == EAccModeLoopset ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if ( aAccessoryState == EAccModeTextDevice ) + TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL : START" ) ) ); + + // In case of unexpected reset (e.g. hidden boot) the keylock must be enabled silently. Locking is done + // prior to time-consuming initializations, because otherwise UI is in unlocked state for a few seconds. + if ( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive ) == 1 ) { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if ( aAccessoryState == EAccModeWirelessCarKit || aAccessoryState == EAccModeWiredCarKit ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if ( aAccessoryState == EAccModeTVOut ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOn ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - } - else if (aAccessoryState == EAccModeHDMI ) - { - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOn ); - } - - TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); - TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryConnectedL: swState: %d"), swState ) ); - - if( UiReady() || swState == ESwStateSecurityCheck ) - { - iSysApLightsController->AccessoryConnectedL( ETrue ); + TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL: enabling keylock") ) ); + iKeyguardController->EnableKeyguard(ETrue); } - if ( ( ! iIgnoreAccessorySpecificProfileChanges ) && ( ! iSysApOfflineModeController->OfflineModeActive() ) ) - { - TInt profileId( 0 ); - TInt currentProfile( 0 ); - currentProfile = ActiveProfileId(); + // Initiate bearer change observation +// iSysApConnectionMonitorObserver = CSysApConnectionMonitorObserver::NewL( *this ); - if ( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected ) < 1 ) - // accessory not connected already - { - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected, 1 ); - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApActiveProfileBeforeAccessoryConnected, currentProfile ); - } + TRACES( RDebug::Print( _L("SysAp: trying CSystemLock::NewL" ) ) ); + iSysApSystemLock = CSystemLock::NewL(); - if ( aAccessoryState == EAccModeWirelessCarKit ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApWirelessCarkit ); - } - else if( aAccessoryState == EAccModeWiredHeadset || - aAccessoryState == EAccModeWirelessHeadset ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApHeadset ); - } - else if( aAccessoryState == EAccModeLoopset ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApLoopset ); - } - else if( aAccessoryState == EAccModeTextDevice ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApTty ); - } - else if( aAccessoryState == EAccModeTVOut || aAccessoryState == EAccModeHDMI ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApTvOut ); - } - else if( aAccessoryState == EAccModeHeadphones ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApHeadphones ); - } - else if ( aAccessoryState == EAccModeWiredCarKit ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApCarkit ); - } - else if ( aAccessoryState == EAccModeMusicStand ) - { - profileId = iSysApCenRepController->ProfileIdForSelectedAccessory( ESysApMusicStand ); - } - - // Carkit and music stand have also light on permanently option that needs to be checked - if( aAccessoryState == EAccModeWiredCarKit || aAccessoryState == EAccModeMusicStand ) - { - // When device is placed on a handsfree cradle, keyguard must be disabled (unless device is locked) - // Note: It is assumed that if carkit/music stand is connected, the phone is in the cradle. - if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCall || iKeyLockOnBeforeAlarm ) - { - iKeyLockOnBeforeCradle = ETrue; - - if ( iKeyLockEnabled && !iDeviceLockEnabled ) - { - KeyLock().DisableWithoutNote(); - } - } - } - - if( profileId != KActiveProfile ) - { - /*-1 because the first item in Accessory default profiles shared data values - is KActiveProfile and that must be subtracted from the index of profile to be activated*/ - - profileId -= 1; - - TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryConnectedL: current profile: %d, accessory profile: %d" ), - currentProfile, profileId ) ); - - if ( profileId != currentProfile ) - { - iAccessoryJustConnected = ETrue; - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileUpdateRequired, 1 ); - ActivateProfileL( profileId ); - } - } + + if ( iSysApFeatureManager->Supported( KSysApFeatureIdBatteryInfoPopup ) ) + { + iSysApBatteryInfoController = CSysApBatteryInfoController::NewL( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsConf, + KCoreAppUIsBatteryInformationLowThreshold ) ); } - SetIhfIndicatorL(); - SetHacIndicatorL(); + TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL : END" ) ) ); } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleAccessoryDisconnectedL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleAccessoryDisconnectedL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryDisconnectedL()" ) ) ); - TAccMode accessoryState(EAccModeHandPortable); - if ( iSysApAccessoryObserver ) - { - accessoryState = iSysApAccessoryObserver->GetAccessoryMode(); - } +// ---------------------------------------------------------------------------- +// CSysApAppUi::DoSimChangedFromPreviousBootL() +// ---------------------------------------------------------------------------- - if ( accessoryState == EAccModeHandPortable ) - { - SetIndicatorStateL( EAknIndicatorTvOut, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorLoopset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadset, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorTTY, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHeadsetUnavailable, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorCarkit, EAknIndicatorStateOff ); - SetIndicatorStateL( EAknIndicatorHDMI, EAknIndicatorStateOff ); - - iSysApLightsController->AccessoryConnectedL( EFalse ); - - if ( ! iIgnoreAccessorySpecificProfileChanges ) - { - TInt activeProfile ( ActiveProfileId() ); +void CSysApAppUi::DoSimChangedFromPreviousBootL() + { + TRACES( RDebug::Print( _L("CSysApAppUi::DoSimChangedFromPreviousBootL: iSimChangedDone=%d" ), iSimChangedDone ) ); - TInt activeProfileBeforeConnectingAccessory( - iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApActiveProfileBeforeAccessoryConnected ) - ); - if ( activeProfileBeforeConnectingAccessory < 0 ) // error - { - activeProfileBeforeConnectingAccessory = 0; // General Profile - } - TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryDisconnectedL: active profile now: %d, active profile before: %d," ), - activeProfile, activeProfileBeforeConnectingAccessory ) ); - - if ( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileUpdateRequired ) == 1 ) - { - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileUpdateRequired, 0 ); - if ( activeProfile != activeProfileBeforeConnectingAccessory && ! iSysApOfflineModeController->OfflineModeActive() ) - { - ActivateProfileL( activeProfileBeforeConnectingAccessory ); - } - } - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected, 0 ); - } - } - - SetIhfIndicatorL(); - SetHacIndicatorL(); - - // If lock disabled because of accessory, reactivate it, unless phone call or alarm is ongoing - if ( iKeyLockOnBeforeCradle ) + if ( !iSimChangedDone ) { - iKeyLockOnBeforeCradle = EFalse; - if ( !iKeyLockOnBeforeCall && !iKeyLockOnBeforeAlarm ) - { - if ( !iDeviceLockEnabled ) - { - KeyLock().EnableKeyLock(); - } - else - { - KeyLock().EnableAutoLockEmulation(); - } - } + iSimChangedDone = ETrue; + CSysApSimChanged* simChanged = CSysApSimChanged::NewL( *this, iEikonEnv->FsSession() ); + CleanupStack::PushL( simChanged ); + simChanged->HandleSimChangedL(); + CleanupStack::PopAndDestroy( simChanged ); } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleAccessoryProfileInStartupL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleAccessoryProfileInStartupL() - { - TRACES( RDebug::Print( _L( "CSysApAppUi::HandleAccessoryProfileInStartupL" ) ) ); - - if ( !iSysApOfflineModeController->OfflineModeActive() ) - { - iIgnoreAccessorySpecificProfileChanges = EFalse; - TBool accessoryConnectedInShutdown( EFalse ); - TInt accessoryTemp( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected ) ); - if ( accessoryTemp == 1 ) - { - accessoryConnectedInShutdown = ETrue; - } - - TBool accessoryConnectedNow ( EFalse ); - - TAccMode accessoryState(EAccModeHandPortable); - if ( iSysApAccessoryObserver ) - { - accessoryState = iSysApAccessoryObserver->GetAccessoryMode(); - } - - if ( accessoryState != EAccModeHandPortable ) - { - accessoryConnectedNow = ETrue; - } - TRACES( RDebug::Print( _L( "CSysApAppUi::HandleAccessoryProfileInStartupL: accessoryConnectedInShutdown: %d, accessoryConnectedNow: %d" ), - accessoryConnectedInShutdown, accessoryConnectedNow ) ); - - if ( accessoryConnectedInShutdown && !accessoryConnectedNow ) - { - HandleAccessoryDisconnectedL(); - } - else if ( !accessoryConnectedInShutdown && accessoryConnectedNow ) - { - HandleAccessoryConnectedL( accessoryState ); - } - else if ( !accessoryConnectedNow ) - { - TInt activeProfile ( ActiveProfileId() ); - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApActiveProfileBeforeAccessoryConnected, activeProfile ); - } - } - } - -#ifndef RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ResolveUidFromThread() -// ---------------------------------------------------------------------------- -TInt32 CSysApAppUi::ResolveUidFromThread( TUint aThreadId ) const - { - TInt resolvedUid = 0; - - RThread appThread; - TInt err = appThread.Open( aThreadId ); - - if ( err == KErrNone ) - { - resolvedUid = appThread.SecureId().iId; - } - - appThread.Close(); - - TRACES( RDebug::Print( _L("CSysApAppUi::ResolveUidFromThread: err=%d, aThreadId=%d, resolvedUid=0x%x"), - err, aThreadId, resolvedUid ) ); - - return resolvedUid; - } // ---------------------------------------------------------------------------- -// CSysApAppUi::CloseUIAppsInHotSwapL() +// CSysApAppUi::IgnoreZeroNetworkBarNotifications // ---------------------------------------------------------------------------- -void CSysApAppUi::CloseUIAppsInHotSwapL() +// +void CSysApAppUi::IgnoreZeroNetworkBarNotifications(TBool aIgnore) { - TRACES( RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL") ) ); - - CArrayFixFlat* wgIds=new(ELeave) CArrayFixFlat(4); - CleanupStack::PushL(wgIds); - User::LeaveIfError(iCoeEnv->WsSession().WindowGroupList(0, wgIds)); - TInt lastEntry=wgIds->Count()-1; - TRACES( RDebug::Print( _L( "CSysApAppUi::CloseUIAppsInHotSwapL: Found %d UI applications running." ), lastEntry + 1 ) ); - TInt numberOfApplicationsToShutDown( 0 ); - iApplicationScanningRoundNumber++; - - for ( TInt i=lastEntry; i>=0; i--) - { - CApaWindowGroupName* doomedApp = CApaWindowGroupName::NewLC(iCoeEnv->WsSession(),wgIds->At(i)); - - TBool systemApp = doomedApp->IsSystem(); - TBool hiddenApp = doomedApp->Hidden(); - - if ( systemApp || hiddenApp ) - { - TRACES ( - TPtrC caption=doomedApp->Caption(); - RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL: Privileged app \"%S\" UID 0x%x will not be closed, system: %d, hidden: %d" ), - &caption, - doomedApp->AppUid().iUid, - systemApp, - hiddenApp); - ); - } - else if ( ( iFileManagerCloseDisabled && doomedApp->AppUid().iUid == KFileManagerAppUid ) || - doomedApp->AppUid().iUid == KAutolockAppUid ) - { - // An additional failure protection: Autolock must not be closed in any circumstances - TRACES ( - TPtrC caption=doomedApp->Caption(); - RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL: Privileged app \"%S\" will not be closed, UID 0x%x"), - &caption, - doomedApp->AppUid().iUid ); - ); - } - else if ( doomedApp->AppUid().iUid == 0 && !iTimeToKill ) - { -#ifdef _DEBUG - TApaTask task(iCoeEnv->WsSession()); - task.SetWgId(wgIds->At(i)); - TUint threadId = (TUint)(task.ThreadId()); - TInt32 uid = ResolveUidFromThread( threadId ); - // CApaWindowGroupName stores the application UID, and in early application startup state AppUid()-method returns 0 - // In order not to accidentally close application that hasn't yet its window group properly set up, decicision whether - // to close the application is postponed, in maximum to the end of the waiting period. - TRACES ( RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL: Unknown app will not be closed yet, threadId=%d, UID 0x%x, size=%d"), - threadId, uid, sizeof(TApaTask) ) ); -#endif // _DEBUG - numberOfApplicationsToShutDown++; // wait note must be displayed - } - else - { - numberOfApplicationsToShutDown++; - TApaTask* task = new (ELeave) TApaTask(iCoeEnv->WsSession()); - CleanupDeletePushL(task); - task->SetWgId(wgIds->At(i)); - - TRACES ( - const TDesC& caption = doomedApp->Caption(); - const TDesC& docname = doomedApp->DocName(); - const TDesC& wgname = doomedApp->WindowGroupName(); - TUid uid = doomedApp->AppUid(); - RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL: Closing app \"%S\" (ThreadId %d, WgId %d, UID 0x%X); Docname: %S, WGName : %S"), - &caption, - (TUint)(task->ThreadId()), - wgIds->At(i), - uid.iUid, - &docname, - &wgname); - ); - - ResolveUidFromThread( (TUint)(task->ThreadId()) ); - - if ( iApplicationScanningRoundNumber == 1 ) - { - task->EndTask(); // applications are kindly requested to close themselves on the first round - } - else if ( iTimeToKill ) - { - TBool doKill = ETrue; - - // final check, window group may still be uninitialized so use thread id for checking UID - if ( doomedApp->AppUid().iUid == 0 ) - { - if ( ResolveUidFromThread( (TUint)(task->ThreadId()) ) == KAutolockAppUid ) - { - doKill = EFalse; - } - } - - if ( doKill ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL: Killing app \"%S\""), &caption ) ); - task->KillTask(); // used after timeout on the last round - } - } - - CleanupStack::PopAndDestroy(); // task - } - CleanupStack::PopAndDestroy(); // doomedApp - } - CleanupStack::PopAndDestroy(); // wgIds - - if ( numberOfApplicationsToShutDown > 0 && iApplicationScanningRoundNumber <= KMaxExitTimeInHotSwap ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL: Show wait note, unless already showing") ) ); - if ( !iSysApWaitNote ) - { - HBufC* noteStringBuf = StringLoader::LoadLC( R_QTN_MEMC_WAIT_EJECT, iEikonEnv ); - iSysApWaitNote = CSysApWaitNote::NewL( iSysApFeatureManager->CoverDisplaySupported() ); - iSysApWaitNote->ShowNoteL( EClosingApplicationsNote, noteStringBuf ); - CleanupStack::PopAndDestroy(); - } - - if ( iApplicationScanningRoundNumber >= KMaxExitTimeInHotSwap ) - { - iTimeToKill = ETrue; - } - - if ( !iSysApTimer ) - { - iSysApTimer = new ( ELeave ) CSysApTimer( *this ); - } - - iSysApTimer->ActivateTimerL( KApplicationScanningInterval ); - } - else - { - iFileManagerCloseDisabled = EFalse; - CompleteAppsShuttingInHotSwapL(); - } + iIgnoreZeroNetworkBarNotifications = aIgnore; } -#endif // RD_MULTIPLE_DRIVE + // ---------------------------------------------------------------------------- -// CSysApAppUi::TimerExpiredL() +// CSysApAppUi::SwitchFromOnlineToOfflineModeL() // ---------------------------------------------------------------------------- -void CSysApAppUi::TimerExpiredL() +void CSysApAppUi::SwitchFromOnlineToOfflineModeL() { -#ifndef RD_MULTIPLE_DRIVE - CloseUIAppsInHotSwapL(); -#endif // RD_MULTIPLE_DRIVE + iSysApOfflineModeController->SwitchFromOnlineToOfflineModeL(); } -#ifndef RD_MULTIPLE_DRIVE -// ---------------------------------------------------------------------------- -// CSysApAppUi::CompleteAppsShuttingInHotSwapL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::CompleteAppsShuttingInHotSwapL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::CompleteAppsShuttingInHotSwapL iMMCEjectUsed=%d, iMMCInserted=%d"), iMMCEjectUsed, iMMCInserted ) ); - CancelWaitNote(); - - if ( iMMCEjectUsed ) // From Powerkey Menu - { - DismountMMC(); - TRACES( RDebug::Print( _L( "CSysApAppUi::CompleteAppsShuttingInHotSwapL: Show note: Remove MMC and press OK...." ) ) ); - ShowQueryL( ESysApRemoveMmcNote ); - } - else if ( !iMMCInserted ) // The MMC might have been already re-mounted, that's why !iMMCInserted - { - ShowMMCDismountedDialogL(); - } - } -#endif // RD_MULTIPLE_DRIVE // ---------------------------------------------------------------------------- // CSysApAppUi::InitCloseSimApplicationsL() @@ -3125,6 +1522,7 @@ CloseSimApplicationsL(); } + // ---------------------------------------------------------------------------- // CSysApAppUi::CloseSimApplicationsL() // ---------------------------------------------------------------------------- @@ -3186,6 +1584,7 @@ } } + // ---------------------------------------------------------------------------- // CSysApAppUi::DoCloseSimApplicationsAfterCallBack // ---------------------------------------------------------------------------- @@ -3203,6 +1602,63 @@ return KErrNone; } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::NotifyPowerSaveModeL +// ---------------------------------------------------------------------------- +// +void CSysApAppUi::NotifyPowerSaveModeL( TSysApPsmStatus aStatus ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::NotifyPowerSaveModeL aStatus: %d"), aStatus ) ); + + // cancel any active power saving query because user has changed the state manually + // CancelQuery( ESysApBattChargingPowerSavingQuery ); + // CancelQuery( ESysApBattLowPowerSavingQuery ); + // will take care in next sub + + switch ( aStatus ) + { + case MSysApPsmControllerNotifyCallback::EPsmActivationComplete: + UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); + ShowUiNoteL( EPowerSaveModeActivated ); + break; + + case MSysApPsmControllerNotifyCallback::EPsmDeactivationComplete: + UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); + ShowUiNoteL( EPowerSaveModeDeactivated ); + break; + + case MSysApPsmControllerNotifyCallback::EPsmActivationFailed: + ShowUiNoteL( ECannotActivatePowerSaveMode ); + break; + + case MSysApPsmControllerNotifyCallback::EPsmDeactivationFailed: + ShowUiNoteL( ECannotDeactivatePowerSaveMode ); + break; + + default: + break; + } + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::ShowAlarmIndicatorL() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::ShowAlarmIndicatorL( TBool aShowIndicator ) + { + if ( aShowIndicator) + { + // do nothing + } + else + { + // do nothing + } + } + + // ---------------------------------------------------------------------------- // CSysApAppUi::AlertUiAlertingL( const TBool aAlerting ) // ---------------------------------------------------------------------------- @@ -3224,6 +1680,45 @@ iSysApLightsController->AlarmOccuredL( aAlerting ); } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleForcedLightsVTRequireL( const TInt aLightParameter ) +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleForcedLightsVTRequireL( const TInt aLightsParameter ) const + { + iSysApLightsController->HandleForcedLightsVTRequireL( aLightsParameter ); + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleForcedLightsSSRequireL( const TInt aLightParameter ) +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleForcedLightsSSRequireL( const TInt aLightsParameter ) const + { + iSysApLightsController->HandleForcedLightsSSRequireL( aLightsParameter ); + } + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleForcedLightsATCRequireL( const TInt aLightParameter ) +// ---------------------------------------------------------------------------- +void CSysApAppUi::HandleForcedLightsATCRequireL( const TInt aLightsParameter ) const + { + iSysApLightsController->HandleForcedLightsATCRequireL( aLightsParameter ); + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleLightsRequireL() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleLightsRequireL() const + { + iSysApLightsController->HandleLightsRequireL(); + } + + // ---------------------------------------------------------------------------- // CSysApAppUi::AlertUiKeyLockOff( const TBool aKeyLockOff ) // ---------------------------------------------------------------------------- @@ -3243,7 +1738,7 @@ iKeyLockOnBeforeAlarm = ETrue; } } - KeyLock().DisableWithoutNote(); + iKeyguardController->DisableKeyguard(EFalse); } else { @@ -3254,61 +1749,33 @@ TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ); if ( callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateConnected ) { - KeyLock().EnableAutoLockEmulation(); + iKeyguardController->EnableKeyguard(EFalse); } } else if ( iKeyLockOnBeforeAlarm && !iKeyLockOnBeforeCradle && !iKeyLockOnBeforeCall ) { - KeyLock().EnableKeyLock(); + iKeyguardController->EnableKeyguard(ETrue); } iKeyLockOnBeforeAlarm = EFalse; } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleLightsRequireL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleLightsRequireL() const - { - iSysApLightsController->HandleLightsRequireL(); - } // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleRawKeyEventLightsRequireL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleRawKeyEventLightsRequireL() const - { - iSysApLightsController->HandleRawKeyEventLightsRequireL(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleForcedLightsVTRequireL( const TInt aLightParameter ) +// CSysApAppUi::DoNotEnableKeylock() // ---------------------------------------------------------------------------- -void CSysApAppUi::HandleForcedLightsVTRequireL( const TInt aLightsParameter ) const +void CSysApAppUi::DoNotEnableKeylock() { - iSysApLightsController->HandleForcedLightsVTRequireL( aLightsParameter ); + if ( !iKeyLockOnBeforeCradle ) + { + iShowkeypadActivatedNoteAfterSoftReject = iKeyLockOnBeforeCall; + } + + iKeyLockOnBeforeCall = EFalse; } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleForcedLightsSSRequireL( const TInt aLightParameter ) -// ---------------------------------------------------------------------------- -void CSysApAppUi::HandleForcedLightsSSRequireL( const TInt aLightsParameter ) const - { - iSysApLightsController->HandleForcedLightsSSRequireL( aLightsParameter ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleForcedLightsATCRequireL( const TInt aLightParameter ) -// ---------------------------------------------------------------------------- -void CSysApAppUi::HandleForcedLightsATCRequireL( const TInt aLightsParameter ) const - { - iSysApLightsController->HandleForcedLightsATCRequireL( aLightsParameter ); - } - // ---------------------------------------------------------------------------- // CSysApAppUi::SwitchLightsOnSoftRejectL() // ---------------------------------------------------------------------------- @@ -3317,605 +1784,6 @@ iSysApLightsController->SwitchLightsOnSoftRejectL(); } -// ---------------------------------------------------------------------------- -// CSysApAppUi::StateOfProperty() -// ---------------------------------------------------------------------------- -TInt CSysApAppUi::StateOfProperty( const TUid& aCategory, const TUint aKey ) const - { - TInt err( KErrNone ); - TInt value( 0 ); - err = RProperty::Get( aCategory, aKey, value ); - if ( err ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::StateOfProperty. RProperty::Get: err=%d"), err ) ); - return err; - } - return value; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::BluetoothPowerMode() -// ---------------------------------------------------------------------------- -TInt CSysApAppUi::BluetoothPowerMode() const - { - return iSysApCenRepBtObserver->BluetoothPowerMode(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ActivateProfileL( const TInt aProfileId ) const -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ActivateProfileL( const TInt aProfileId ) const - { - TRACES( RDebug::Print( _L("CSysApAppUi::ActivateProfile aProfileId: %d"), aProfileId ) ); - //No use of returning the Profile error code since it only tells if the activation was succesfull or not. - iProfileEngine->SetActiveProfileL( aProfileId ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ActivateOnlineProfileL() const -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ActivateOnlineProfileL() const - { - ActivateProfileL( iProfileToBeActivated ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ActiveProfileNameL( TPtr aProfileName ) const -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ActiveProfileNameL( TPtr aProfileName ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::ActiveProfileNameL START") ) ); - MProfile* profile = iProfileEngine->ActiveProfileL(); - const MProfileName& mProfileName = profile->ProfileName(); - aProfileName = mProfileName.Name(); - profile->Release(); - TRACES( RDebug::Print( _L("CSysApAppUi::ActiveProfileNameL END") ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::CheckSilentModeL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::CheckSilentModeL() - { - TBool isSilent( EFalse ); - MProfile* profile = iProfileEngine->ActiveProfileL(); - isSilent = profile->IsSilent(); - profile->Release(); - if ( isSilent ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::CheckSilentModeL: active profile is SILENT") ) ); - iSysApLightsController->SetSilentModeOn( ETrue ); - } - else - { - TRACES( RDebug::Print( _L("CSysApAppUi::CheckSilentModeL: active profile is NOT SILENT") ) ); - iSysApLightsController->SetSilentModeOn( EFalse ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleProfileChangedL( const TInt aValue ) -// ---------------------------------------------------------------------------- -void CSysApAppUi::HandleProfileChangedL( const TInt aNewProfileId ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleProfileChangedL: aNewProfileId=%d"), aNewProfileId ) ); - CheckSilentModeL(); - if ( iHandleNextProfileEvent ) - { - if ( iAccessoryJustConnected ) - { - iAccessoryJustConnected = EFalse; - } - else - { - // if the user delibarately changes profiles, the selected profile will - // remain active after disconnecting an accessory. - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileUpdateRequired, 0 ); - } - - // Added as a part of REQ 415-6750 : Conditional UI-note for "Activated profile" - TInt noNeedToShowTheNote = 0; // if True, then note should not be shown - TInt err = KErrNone; - - err = RProperty::Get( KPSUidCoreApplicationUIs, KCoreAppUIsProfileActivatedNote, - noNeedToShowTheNote ); - /* - If there occured an error, it is likely caused by the non-existing property. - So trying to set it only if no error occured for maintaining the default behavior. - */ - if( KErrNone == err ) - { - TInt error = RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsProfileActivatedNote, - ECoreAppUIsProfileActivatedNoteNotShown ); - } - - if(!noNeedToShowTheNote) // The value doesn't deny the showing, then... - { - ShowProfileNoteL(); - } - } - - if ( aNewProfileId != KOfflineModeProfileId ) - { - iActiveProfileBeforeOfflineMode = aNewProfileId; - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileBeforeOfflineMode, aNewProfileId ); - } - - if ( aNewProfileId == KOfflineModeProfileId && ! iSysApOfflineModeController->OfflineModeActive() ) - { - if ( BtSapEnabled() ) - { - // Choosing "Offline Mode" will disconnect BT SAP - // SwitchFromOnlineToOfflineModeL() will be called from CSysApBtSapController - iSysApBtSapController->SwitchingToOffline(); - iSysApBtSapController->Disconnect(); - } - else - { - SwitchFromOnlineToOfflineModeL(); - } - } - else if ( aNewProfileId != KOfflineModeProfileId && iSysApOfflineModeController->OfflineModeActive() ) - { - if ( BtSapEnabled() ) - { - iSysApOfflineModeController->DoNotActivateRF(); // Will be activated after BT SAP disconnection - } - iSysApOfflineModeController->SwitchFromOfflineToOnlineModeL(); - } - iHandleNextProfileEvent = ETrue; - } - - -// ---------------------------------------------------------------------------- -// CSysApAppUi::RestoreProfileL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::RestoreProfileL( const TBool aOffline ) - { - iHandleNextProfileEvent = EFalse; - if ( aOffline ) - { - ActivateProfileL( KOfflineModeProfileId ); - } - else - { - ActivateProfileL( iActiveProfileBeforeOfflineMode ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ActiveProfileId() -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::ActiveProfileId() - { - return iProfileEngine->ActiveProfileId(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowPowerKeyPopUpMenuL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShowPowerKeyPopUpMenuL() - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL iPowerKeyPopupMenuActive: %d" ), - iPowerKeyPopupMenuActive ) ); - - if ( !iPowerKeyPopupMenuActive && !iDisablePowerkeyMenu - && iSysApPowerKeyMenuObserver ) // normal state construction has been executed - { - iPowerKeyPopupMenuDismissed = EFalse; - iPowerkeyMenuPowerOffShown = EFalse; - CancelGlobalListQuery(); - - iGlobalListQuery = CAknGlobalListQuery::NewL(); - - iSysApPowerKeyMenuObserver->Cancel(); - - CDesCArray* profileNameCDesCArray; // Array for Powerkey Menu items - - RArray itemIdArray; // needed for cover UI - CleanupClosePushL(itemIdArray); - - // make sure old profile names array is clean - delete iProfileNamesArray; - iProfileNamesArray = NULL; - - // Must pop iProfileNamesArray here as cannot leave trap harness with uneven push/pop count. - // This is because profileEngine doesn't provide non-LC version of ProfilesNamesArrayLC - TRAPD( err, - iProfileNamesArray = iProfileEngine->ProfilesNamesArrayLC(); - CleanupStack::Pop(); - ); - - if ( err != KErrNone ) - { - // creating menu failed, return (i.e. just don't show the menu) - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL iProfileEngine->ProfilesNamesArrayLC() ERROR: %d" ), err ) ); - iNumberOfProfileNamesInPowerKeyMenu = 0; - } - else - { - iNumberOfProfileNamesInPowerKeyMenu = iProfileNamesArray->MdcaCount(); - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL iNumberOfProfileNamesInPowerKeyMenu: %d" ), - iNumberOfProfileNamesInPowerKeyMenu ) ); - } - - if ( BtSapEnabled() ) - { - profileNameCDesCArray = new( ELeave ) CDesCArrayFlat( iNumberOfProfileNamesInPowerKeyMenu + 4 ); - } - else - { - profileNameCDesCArray = new( ELeave ) CDesCArrayFlat( iNumberOfProfileNamesInPowerKeyMenu + 3 ); - } - - CleanupStack::PushL( profileNameCDesCArray ); - profileNameCDesCArray->Reset(); - HBufC* itemStringBuf; - - TInt powerMenuItemIndex( 0 ); - - // "Switch off" menu item - if ( !IsEncryptionOperationOngoingL() ) - { - itemStringBuf = StringLoader::LoadLC( R_QTN_PWRC_SWITCH_OFF, iEikonEnv ); - profileNameCDesCArray->InsertL( 0, itemStringBuf->Des() ); - CleanupStack::PopAndDestroy(); // itemStringBuf - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL(SecondaryDisplay::EPwrMenuItemSwitchOff); - } - iPowerkeyMenuPowerOffShown = ETrue; - powerMenuItemIndex++; - } - - iPowerkeyMenuLockKeypadShown = EFalse; - iPowerkeyMenuExitSapShown = EFalse; - iPowerkeyMenuLockSystemShown = EFalse; - iPowerkeyMenuEjectShown = EFalse; - - iPowerkeyMenuLockKeypadSelection = KErrAccessDenied; - iPowerkeyMenuExitSapSelection = KErrAccessDenied; - iPowerkeyMenuLockSystemSelection = KErrAccessDenied; - -#ifndef RD_MULTIPLE_DRIVE - iPowerkeyMenuEjectSelection = KErrAccessDenied; -#else // RD_MULTIPLE_DRIVE - iPowerkeyMenuEjectSelectionBase = KErrAccessDenied; -#endif // RD_MULTIPLE_DRIVE - - // "Lock keypad" menu item - - TInt callState ( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ); - TInt callType ( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallType ) ); - if ( !( callState == EPSCTsyCallStateConnected && callType == EPSCTsyCallTypeH324Multimedia ) ) - { - if ( iSysApFeatureManager->GripNotSupported() || - ( (!iSysApFeatureManager->GripNotSupported() ) && ( StateOfProperty( KPSUidHWRM, KHWRMGripStatus ) == EPSHWRMGripClosed ) ) ) - // "Lock keypad" command is shown always when there is no grip, and if there - // there is no grip, only when the grip is closed. - { - if ( CKeyLockPolicyApi::KeyguardAllowed() ) - { - if ( iSysApFeatureManager->PenEnabled() ) - { - itemStringBuf = StringLoader::LoadLC( R_QTN_PWRC_LOCK_DISPLAY, iEikonEnv ); - } - else - { - itemStringBuf = StringLoader::LoadLC( R_QTN_PWRC_LOCK_KEYS, iEikonEnv ); - } - profileNameCDesCArray->AppendL( itemStringBuf->Des() ); - CleanupStack::PopAndDestroy(); // itemStringBuf - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL(SecondaryDisplay::EPwrMenuItemLockKeypad); - } - iPowerkeyMenuLockKeypadShown = ETrue; - iPowerkeyMenuLockKeypadSelection = powerMenuItemIndex; - powerMenuItemIndex++; - } - } - } - - // "Exit SIM access profile" menu item - - if ( BtSapEnabled() ) - { - TRACES( RDebug::Print(_L( "CSysApAppUi::ShowPowerKeyPopUpMenuL: show \"Exit SIM access profile\" item" ) ) ); - itemStringBuf = StringLoader::LoadLC( R_QTN_PWRC_EXIT_SIM_ACCESS, iEikonEnv ); - profileNameCDesCArray->AppendL( itemStringBuf->Des() ); - CleanupStack::PopAndDestroy(); // itemStringBuf - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL(SecondaryDisplay::EPwrMenuItemExitBtSap); - } - iPowerkeyMenuExitSapShown = ETrue; - iPowerkeyMenuExitSapSelection = powerMenuItemIndex; - powerMenuItemIndex++; - } - - // Profile menu items - - TInt arrayIndex ( 0 ); - TBufC profileName; - - for ( arrayIndex = 0; arrayIndex < iNumberOfProfileNamesInPowerKeyMenu; arrayIndex++ ) - { - profileName = iProfileNamesArray->MdcaPoint( arrayIndex ); - TPtr profileNamePtr = profileName.Des(); - AknTextUtils::DisplayTextLanguageSpecificNumberConversion( profileNamePtr ); - profileNameCDesCArray->AppendL( profileNamePtr ); - - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - TInt profileId = ( iProfileNamesArray->ProfileName( arrayIndex ) )->Id(); - itemIdArray.AppendL(SecondaryDisplay::EPwrMenuItemProfileItemBase+profileId); - } - powerMenuItemIndex++; - } - - // "Lock device" menu item - - callState = StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ); - - TInt devLockStatus( EAutolockStatusUninitialized ); - devLockStatus = StateOfProperty( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus ); // check whether Autolock has been started - - - if ( callState == EPSCTsyCallStateNone && devLockStatus != EAutolockStatusUninitialized ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL: adding \"Lock device\", devLockStatus=%d" ), devLockStatus ) ); - iPowerkeyMenuLockSystemShown = ETrue; - itemStringBuf = StringLoader::LoadLC( R_QTN_SET_SEC_LOCK_SYSTEM, iEikonEnv ); - profileNameCDesCArray->AppendL( itemStringBuf->Des() ); - CleanupStack::PopAndDestroy(); // itemStringBuf - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL(SecondaryDisplay::EPwrMenuItemLockDevice); - } - iPowerkeyMenuLockSystemShown = ETrue; - iPowerkeyMenuLockSystemSelection = powerMenuItemIndex; - powerMenuItemIndex++; - } - - // "Eject MMC" menu item - - TInt propertyValue( StateOfProperty( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality ) ); - -#ifndef RD_MULTIPLE_DRIVE - if ( !IsEncryptionOperationOngoingL() ) - { - if ( iSysApFeatureManager->MmcHotSwapSupported() && - iMMCInserted && - iSysApFeatureManager->EjectRequiredInPowerMenu() && - propertyValue != KUsbPersonalityIdMS ) - { - iPowerkeyMenuEjectShown = ETrue; - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL: adding \"Eject\"" ) ) ); - itemStringBuf = StringLoader::LoadLC( R_QTN_PWRC_EJECT_MMC, iEikonEnv ); - profileNameCDesCArray->AppendL( itemStringBuf->Des() ); - CleanupStack::PopAndDestroy(); // itemStringBuf - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL(SecondaryDisplay::EPwrMenuItemEjectMMC); - } - iPowerkeyMenuEjectShown = ETrue; - iPowerkeyMenuEjectSelection = powerMenuItemIndex; - powerMenuItemIndex++; - } - } - -#else // RD_MULTIPLE_DRIVE - if ( !IsEncryptionOperationOngoingL() ) - { - if ( iSysApFeatureManager->MmcHotSwapSupported() && - iSysApFeatureManager->EjectRequiredInPowerMenu() && - propertyValue != KUsbPersonalityIdMS ) - { - // Reset old eject status and dialog - iSysApDriveList->ResetDrivesToEject(); - if ( iSysApConfirmationQuery ) - { - if ( iSysApConfirmationQuery->CurrentQuery() == ESysApEjectMmcQuery ) - { - iSysApConfirmationQuery->Cancel(); - } - } - - // Append memory cards for eject selection - TInt count( iInsertedMemoryCards.Count() ); - for ( TInt i( 0 ); i < count; ++i ) - { - itemStringBuf = iSysApDriveList->GetFormattedDriveNameLC( - iInsertedMemoryCards[ i ].iDrive, - R_QTN_PWRC_EJECT_MEMORY_STORAGE ); - profileNameCDesCArray->AppendL( *itemStringBuf ); - CleanupStack::PopAndDestroy( itemStringBuf ); - - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL( SecondaryDisplay::EPwrMenuItemEjectItemBase + i ); - } - } - if ( count > 0 ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL: added \"Eject\"" ) ) ); - iPowerkeyMenuEjectShown = ETrue; - iPowerkeyMenuEjectSelectionBase = powerMenuItemIndex; - powerMenuItemIndex += count; - } - } - } -#endif // RD_MULTIPLE_DRIVE - - // Activate/deactive power save mode - if ( iSysApPsmController ) // variable feature, not create if power save is not used - { - TBool showActivate = !(iSysApPsmController->FullPsmEnabled()); - - TInt textId = ( showActivate ? R_QTN_PWRC_ACTIVATE_POWER_SAVING : R_QTN_PWRC_DEACTIVATE_POWER_SAVING ); - - itemStringBuf = StringLoader::LoadLC( textId, iEikonEnv ); - iSysApPsmController->SetNextUiOperation( showActivate ); - - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - itemIdArray.AppendL( showActivate ? - SecondaryDisplay::EPwrMenuItemActivatePowerSaving : - SecondaryDisplay::EPwrMenuItemDeactivatePowerSaving ); - } - - profileNameCDesCArray->AppendL( itemStringBuf->Des() ); - CleanupStack::PopAndDestroy( itemStringBuf ); - - iSysApPsmController->SetUiItemId( powerMenuItemIndex ); - powerMenuItemIndex++; - } - - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL NumberOfAllItemsInPowerKeyMenu: %d" ), - profileNameCDesCArray->Count() ) ); - - iSysApPowerKeyMenuObserver->Start(); - - // Set secondary display data if necessary - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - CAknSDData* sd = CAknSDData::NewL(SecondaryDisplay::KCatSysAp, SecondaryDisplay::ECmdShowPowerKeyListQuery, KNullDesC8); - sd->InsertGlobalListQueryItemIdsL(itemIdArray); - iGlobalListQuery->SetSecondaryDisplayData(sd); // ownership to notifier client - } - - iGlobalListQuery->ShowListQueryL( (MDesCArray*) profileNameCDesCArray, - iSysApPowerKeyMenuObserver->iStatus, - KProfileListInitialIndex ); - - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL: list query shown" ) ) ); - - CleanupStack::PopAndDestroy( profileNameCDesCArray ); // profileNameCDesCArray - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL: profileNameCDesCArray popped" ) ) ); - - CleanupStack::Pop(&itemIdArray); - itemIdArray.Close(); - - // Without following variable set ETrue powerkey up event would change the hightlighted item to be - // the second one instead of the wanted first one. - iIgnoreNextPowerKeyUpEvent = ETrue; - - if ( iSysApBatteryInfoController ) - { - iSysApBatteryInfoController->PowerMenuShownL(); - } - - TRACES( RDebug::Print(_L("CSysApAppUi::ShowPowerKeyPopUpMenuL:end" ) ) ); - } -} - -// ---------------------------------------------------------------------------- -// CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL( TInt aSelection ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL( TInt aSelection ) - { - iPowerKeyPopupMenuDismissed = ETrue; - iPowerKeyPopupMenuActive = EFalse; - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: START aSelection:%d" ), aSelection ) ); - if ( aSelection == KPowerKeyMenuSelectionCancelled ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: Powerkey menu cancelled" ) ) ); - } - else if( aSelection < KPowerKeyMenuSelectionCancelled ) - { - iIgnoreNextPowerKeyUpEvent = EFalse; - } - else - { - TInt firstProfileItemIndex( 1 + Max( 0, iPowerkeyMenuLockKeypadSelection, iPowerkeyMenuExitSapSelection ) ); // index of "General" profile - - if ( aSelection == KPowerKeyMenuSelectionSwitchOff ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Switch off\" selected" ) ) ); - DoShutdownL( EFalse, KDummyReason ); - } - - else if ( iPowerkeyMenuLockKeypadShown && aSelection == iPowerkeyMenuLockKeypadSelection ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Lock keypad\" selected" ) ) ); - KeyLock().EnableKeyLock(); - } - - else if ( iPowerkeyMenuExitSapShown && aSelection == iPowerkeyMenuExitSapSelection ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Exit SAP\" selected" ) ) ); - ShowQueryL( ESysApBtSapDisconnectQuery ); - } - - else if ( aSelection < firstProfileItemIndex + iNumberOfProfileNamesInPowerKeyMenu ) - { - __ASSERT_DEBUG( iProfileNamesArray, User::Invariant() ); - - if ( iProfileNamesArray ) - { - iProfileToBeActivated = ( iProfileNamesArray->ProfileName( aSelection - firstProfileItemIndex ) )->Id(); - - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: profile id: %d selected" ), iProfileToBeActivated ) ); - if ( ! iSysApOfflineModeController->OfflineModeActive() || - ( iProfileToBeActivated ) == KOfflineModeProfileId ) - { - ActivateProfileL( iProfileToBeActivated ); - } - else - { - // iProfileToBeActivated profile will be activated from iSysApOfflineModeController if ok - iSysApOfflineModeController->GoOnlineIfOkL(); - } - } - } - - else if ( iPowerkeyMenuLockSystemShown && aSelection == iPowerkeyMenuLockSystemSelection ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Lock system\" selected" ) ) ); - iSysApSystemLock->SetLockedL(); - } -#ifndef RD_MULTIPLE_DRIVE - else if ( iPowerkeyMenuEjectShown && aSelection == iPowerkeyMenuEjectSelection ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Eject\" selected" ) ) ); - ShowQueryL( ESysApEjectMmcQuery ); - } -#else // RD_MULTIPLE_DRIVE - else if ( iPowerkeyMenuEjectShown && - aSelection >= iPowerkeyMenuEjectSelectionBase && - aSelection < iPowerkeyMenuEjectSelectionBase + iInsertedMemoryCards.Count() ) - { - iDriveToEject = - iInsertedMemoryCards[ aSelection - iPowerkeyMenuEjectSelectionBase ].iDrive; - TRACES( RDebug::Print( - _L( "CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Eject\" selected, drive=%d" ), - iDriveToEject ) ); - iSysApDriveList->ResetDrivesToEject(); - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - EjectMMCL(); - } -#endif // RD_MULTIPLE_DRIVE - else if ( iSysApPsmController && aSelection == iSysApPsmController->UiItemId() ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: \"Activate|Deactivate power save\" selected" ) ) ); - iSysApPsmController->DoEnableFullPsm( iSysApPsmController->NextUiOperation() ); - } - - } - - delete iProfileNamesArray; - iProfileNamesArray = NULL; - - TRACES( RDebug::Print(_L("CSysApAppUi::PowerKeyPopUpMenuSelectionDoneL: END" ) ) ); - } // ---------------------------------------------------------------------------- // CSysApAppUi::SetDeviceLockEnabledL( const TBool aLockEnabled ) @@ -3937,7 +1805,7 @@ { if( iKeyLockEnabled ) { - KeyLock().DisableWithoutNote(); + iKeyguardController->DisableKeyguard(EFalse); } } else @@ -3949,1788 +1817,159 @@ // Memory card needs to be unlocked when device is unlocked if ( iSysApFeatureManager->MmcHotSwapSupported() ) { - RunUnlockNotifierL(); - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoNotEnableKeylock() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::DoNotEnableKeylock() - { - if ( !iKeyLockOnBeforeCradle ) - { - iShowkeypadActivatedNoteAfterSoftReject = iKeyLockOnBeforeCall; - } - - iKeyLockOnBeforeCall = EFalse; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoShutdownL( const TBool aReset, const TSWStartupReason aSWStartupReason ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::DoShutdownL( const TBool aReset, const TInt aResetReason ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: aResetReason:%d, aReset:%d" ), - aResetReason, aReset ) ); -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - TBool animationenabled( EFalse ); -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - if( OkToInitiateShutdown() ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: Was OkToToInitiateShutdown" ) ) ); - - - if ( !aReset && iSysApFeatureManager->Supported(KSysApFeatureIdGoodbyeNote) ) - { - TRAPD( ignore, ShowShutdownNoteL() ); - if ( ignore ) ignore = 0; // hide compiler warning about not using variable - } - - if( !aReset ) - { - #ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION - TRAPD( err, ShowAnimationL() ); - if ( err ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL ShowAnimationL() leaved: %d" ), err ) ); - CompleteShutdown(aReset, aResetReason); - } - } - else // aReset - { - CompleteShutdown(aReset, aResetReason); - } - #else // RD_STARTUP_ANIMATION_CUSTOMIZATION - TRAPD( err, animationenabled = ShowAnimationL() ); - if ( err ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL ShowAnimationL() leaved: %d" ), err ) ); - } - } - - if ( !animationenabled ) - { - CompleteShutdown(aReset, aResetReason); - } - #endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - } - else - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: Was not OkToToInitiateShutdown" ) ) ); - } - TRACES( RDebug::Print(_L("CSysApAppUi::DoShutdownL: END" ) ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ContinueShutdown() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ContinueShutdown() - { - TRACES( RDebug::Print(_L("CSysApAppUi::ContinueShutdown() started" ) ) ); - CompleteShutdown(); - TRACES( RDebug::Print(_L("CSysApAppUi::ContinueShutdown() completed" ) ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowAnimationL() -// ---------------------------------------------------------------------------- - -#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION -void -#else // RD_STARTUP_ANIMATION_CUSTOMIZATION -TBool -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION -CSysApAppUi::ShowAnimationL() - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowAnimationL(): START" ) ) ); - - TRACES( RDebug::Print( _L("CSysApAppUi::ShowAnimationL: Initialise shutdown animation") ) ); - -#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION - - PrepareForShutdownAnimation(); - - iSysApShutdownAnimation = CSysApShutdownAnimation::NewL( *iSysApShutdownImage ); - iSysApShutdownAnimation->Play( TCallBack( DoStopAnimTiming, this ) ); - - TRACES( RDebug::Print(_L("CSysApAppUi::ShowAnimationL(): End" ) ) ); - -#else // RD_STARTUP_ANIMATION_CUSTOMIZATION - iSysApShutdownAnimation = CSysApShutdownAnimation::NewL( this ); - AddToStackL( iSysApShutdownAnimation ); - iAnimationShowingTime = iSysApShutdownAnimation->ShowingTime(); - TRACES( RDebug::Print( _L("CSysApAppUi::ShowAnimationL: Shutdown animation initialised. Animation time = %d") ,iAnimationShowingTime) ); - - TBool ret_val( EFalse ); - - if ( iAnimationShowingTime ) - { - if ( iSysApFeatureManager->CoverDisplaySupported() ) - { - // Construct mediator observer - iSysApMediatorObserver = CSysApMediatorObserver::NewL( this ); - - // Sync animation - TInt err = iSysApMediatorObserver->SyncShutdownAnimation(); - - if ( err != KErrNone ) - { - // Pretend coverUI synced instantly if error in issuing command. - ShutdownAnimationSyncOK(); - } - } - else - { - // Pretend coverUI synced instantly when it is not supported. - ShutdownAnimationSyncOK(); - } - - ret_val = ETrue; - } - - TRACES( RDebug::Print(_L("CSysApAppUi::ShowAnimationL(): returns: %d" ),ret_val ) ); - return ret_val; -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - } - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShutdownAnimationSyncOK() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShutdownAnimationSyncOK() - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShutdownAnimationSyncOK(): Call PrepareForShutdownAnimation()" ) ) ); - PrepareForShutdownAnimation();//SysAp's internal preparation for ShutDown with animation - TRACES( RDebug::Print(_L("CSysApAppUi::ShutdownAnimationSyncOK(): Called PrepareForShutdownAnimation()" ) ) ); - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SkipShutdownAnimation() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::SkipShutdownAnimation() - { - TRACES( RDebug::Print(_L("CSysApAppUi::SkipShutdownAnimation() " ) ) ); - -#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION - if ( iSysApShutdownAnimation ) - { - iSysApShutdownAnimation->Cancel(); - } -#else // RD_STARTUP_ANIMATION_CUSTOMIZATION - if ( iAnimationShowingTime ) - { - iSysApShutdownAnimation->EndAnimation(); - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::NotifyShutdownAnimationSkip() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::NotifyShutdownAnimationSkip() - { - TRACES( RDebug::Print(_L("CSysApAppUi::NotifyShutdownAnimationSkip() " ) ) ); - - if ( iSysApMediatorObserver ) - { - iSysApMediatorObserver->ShutdownAnimationSkipped(); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::CompleteShutdown() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::CompleteShutdown( const TBool aReset, const TInt aResetReason ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::CompleteShutdown(): START" ) ) ); - - PrepareForShutdownImage();//SysAp's internal preparation for ShutDown with image - - FreeResources(); - - if ( aReset ) - { - __ASSERT_DEBUG( aResetReason >= RStarterSession::ELanguageSwitchReset && - aResetReason <= RStarterSession::EDataRestoreReset, - User::Invariant() ); - StarterSession().Reset( static_cast( aResetReason ) ); - } - else - { - StarterSession().Shutdown(); - } - - StarterSession().Close(); - - TRACES( RDebug::Print(_L("CSysApAppUi::CompleteShutdown(): END" ) ) ); - } - -#ifndef SYSAP_USE_STARTUP_UI_PHASE -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState) -// This method is not called after boot has finished. -// ---------------------------------------------------------------------------- - -void CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: %d" ), aSwState ) ); - - switch ( aSwState ) - { - case RStarterSession::ENormal: - SetStatusPaneLayoutL( ESysApNormal ); - break; - case RStarterSession::ECharging: - SetStatusPaneLayoutL( ESysApCharging ); - break; - case RStarterSession::EAlarm: - SetStatusPaneLayoutL( ESysApAlarm ); - break; - default: - break; - }; - - TRAPD( simChangedErr, DoSimChangedFromPreviousBootL() ); - TRACES( RDebug::Print( _L("CSysApAppUi::DoStateChangedL: simChangedErr = %d" ), simChangedErr ) ); - simChangedErr = simChangedErr; // suppress 'variable not used' warning - LogsObserverL().HandleSimChangedCheckDoneL(); - - if ( iSysApFeatureManager->PowerSaveSupported() ) - { - // create controller before checking battery state, so that power saving can be enabled during boot if needed - if ( !iSysApPsmController ) // created only in first state change - { - iSysApPsmController = CSysApPsmController::NewL( *this ); - } - - // in charger boot explicitly disable partial power save mode - if ( aSwState == RStarterSession::ECharging && !iCharging ) - { - iSysApPsmController->ChargerConnected(); - iSysApPsmController->DoEnablePartialPsm( EFalse ); // disable partial power save now + // RunUnlockNotifierL(); + // Need to handle feature for unlocking the MMC card } } - - TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - //Also Charging status will be updated with the following function. - UpdateBatteryBarsL( state ); - - if( IsStateNormal() ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL to normal state.") ) ); - - DoSwStateNormalConstructionL(); - - InitializeStatusPaneAreaL(); - CheckSilentModeL(); - HandleAccessoryProfileInStartupL(); - - if ( iSysApFeatureManager->MmcSupported() ) - { -#ifndef RD_MULTIPLE_DRIVE - MountMMC(); - MMCStatusChangedL(); - iHideFirstBeep = EFalse; -#else // RD_MULTIPLE_DRIVE - iSysApDriveList->MountDrive( iSysApDriveList->DefaultMemoryCard() ); - UpdateInsertedMemoryCardsL(); -#endif // RD_MULTIPLE_DRIVE - } - if ( iSysApFeatureManager->MmcHotSwapSupported() ) - { - iSysApMMCObserver->StartMountObserver(); - } - - - if ( iSysApPsmController ) - { - if ( iCharging ) // if charger is connected on boot PSM queries may need to be shown - { - HandleChargingStatusL( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) ); - } - } - - TInt batteryStatus = StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryStatus ); - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: batteryStatus %d" ), batteryStatus ) ); - if( batteryStatus == EBatteryStatusLow || batteryStatus == EBatteryStatusEmpty ) - { - // low and empty battery states are informed to the user in device startup - HandleBatteryStatusL( batteryStatus ); - } - else if ( iSysApPsmController && !iCharging ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: batteryStatus %d, iCharging %d -> disable partial psm" ), batteryStatus, iCharging ) ); - - iSysApPsmController->BatteryLow( EFalse ); - iSysApPsmController->DoEnablePartialPsm( EFalse ); - } - - iSysApBtController = CreateSysApBtControllerL( *this ); - iSysApBtSapController = CreateSysApBtSapControllerL( *this ); - - if ( iActivateBt ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL Activating BT" ) ) ); - SetBtPowerState( ETrue ); - } - - if ( iDeactivateBt ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL Deactivating BT" ) ) ); - SetBtPowerState( EFalse ); - } - iSysApLocationPrivacyIndicator = CreateSysApLocationPrivacyIndicatorL( *this ); - iSysApLocationPrivacyIndicator->InitL(); - - if ( ! iSysApUsbIndicatorController ) - { - TRAPD ( usbErr, iSysApUsbIndicatorController = CreateSysApUsbIndicatorL( *this ) ); - if ( usbErr ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: error in constructing USB ind. controller %d" ), usbErr ) ); - } - } - - // Other late initializations. - // In order to prevent unexpected behaviour e.g. in OOM situations, these calls are made to ensure - // that the services are connected when they are needed for the first time. - if ( !StarterSession().Handle() ) - { - User::Leave( KErrBadHandle ); - } - - if ( !KeyLock().Handle() ) - { - User::Leave( KErrBadHandle ); - } - -#ifdef __SYSAP_MODULE_TEST - ModuleTestShowUiNoteL( _L("SysAp: SW state normal!") ); -#endif - } - - // Allow lights - iSysApLightsController->AllowLightsOn(); - } - -#else // SYSAP_USE_STARTUP_UI_PHASE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleUiReadyAfterBootL() -// Called when startup UI activities has been finished -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleUiReadyAfterBootL() - { - TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL" ) ) ); - - SetStatusPaneLayoutL( ESysApNormal ); - - TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - //Also Charging status will be updated with the following function. - UpdateBatteryBarsL( state ); - - DoSwStateNormalConstructionL(); - - InitializeStatusPaneAreaL(); - CheckSilentModeL(); - HandleAccessoryProfileInStartupL(); - - if ( iSysApFeatureManager->MmcSupported() ) - { -#ifndef RD_MULTIPLE_DRIVE - MountMMC(); - MMCStatusChangedL(); - iHideFirstBeep = EFalse; -#else // RD_MULTIPLE_DRIVE - iSysApDriveList->MountDrive( iSysApDriveList->DefaultMemoryCard() ); - UpdateInsertedMemoryCardsL(); -#endif // RD_MULTIPLE_DRIVE - } - - if ( iSysApFeatureManager->MmcHotSwapSupported() ) - { - iSysApMMCObserver->StartMountObserver(); - } - - if ( iSysApPsmController ) - { - if ( iCharging ) // if charger is connected on boot PSM queries may need to be shown - { - HandleChargingStatusL( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) ); - } - } - - TInt batteryStatus = StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryStatus ); - TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: batteryStatus %d" ), batteryStatus ) ); - if( batteryStatus == EBatteryStatusLow || batteryStatus == EBatteryStatusEmpty ) - { - // low and empty battery states are informed to the user in device startup - HandleBatteryStatusL( batteryStatus ); - } - else if ( iSysApPsmController && !iCharging ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: batteryStatus %d, iCharging %d -> disable partial psm" ), batteryStatus, iCharging ) ); - - iSysApPsmController->BatteryLow( EFalse ); - iSysApPsmController->DoEnablePartialPsm( EFalse ); - } - - iSysApLocationPrivacyIndicator = CreateSysApLocationPrivacyIndicatorL( *this ); - iSysApLocationPrivacyIndicator->InitL(); - - if ( ! iSysApUsbIndicatorController ) - { - TRAPD ( usbErr, iSysApUsbIndicatorController = CreateSysApUsbIndicatorL( *this ) ); - if ( usbErr ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: error in constructing USB ind. controller %d" ), usbErr ) ); - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState) -// This method is not called after boot has finished. -// ---------------------------------------------------------------------------- - -void CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: %d" ), aSwState ) ); - - switch ( aSwState ) - { - case RStarterSession::ENormal: - // status pane layout will updated when UI is ready - break; - case RStarterSession::ECharging: - SetStatusPaneLayoutL( ESysApCharging ); - break; - case RStarterSession::EAlarm: - SetStatusPaneLayoutL( ESysApAlarm ); - break; - default: - break; - }; - - TRAPD( simChangedErr, DoSimChangedFromPreviousBootL() ); - TRACES( RDebug::Print( _L("CSysApAppUi::DoStateChangedL: simChangedErr = %d" ), simChangedErr ) ); - simChangedErr = simChangedErr; // suppress 'variable not used' warning - LogsObserverL().HandleSimChangedCheckDoneL(); - - if ( iSysApFeatureManager->PowerSaveSupported() ) - { - // create controller before checking battery state, so that power saving can be enabled during boot if needed - if ( !iSysApPsmController ) // created only in first state change - { - iSysApPsmController = CSysApPsmController::NewL( *this ); - } - - // in charger boot explicitly disable partial power save mode - if ( aSwState == RStarterSession::ECharging ) - { - iSysApPsmController->ChargerConnected(); - iSysApPsmController->DoEnablePartialPsm( EFalse ); // disable partial power save now - } - } - - if ( aSwState == RStarterSession::ECharging || aSwState == RStarterSession::EAlarm ) - { - TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - //Also Charging status will be updated with the following function. - UpdateBatteryBarsL( state ); - } - - if( IsStateNormal() ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL to normal state.") ) ); - - iSysApBtController = CreateSysApBtControllerL( *this ); - iSysApBtSapController = CreateSysApBtSapControllerL( *this ); - - if ( iActivateBt ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL Activating BT" ) ) ); - SetBtPowerState( ETrue ); - } - - if ( iDeactivateBt ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL Deactivating BT" ) ) ); - SetBtPowerState( EFalse ); - } - - // Other late initializations. - // In order to prevent unexpected behaviour e.g. in OOM situations, these calls are made to ensure - // that the services are connected when they are needed for the first time. - if ( !StarterSession().Handle() ) - { - User::Leave( KErrBadHandle ); - } - - if ( !KeyLock().Handle() ) - { - User::Leave( KErrBadHandle ); - } - -#ifdef __SYSAP_MODULE_TEST - ModuleTestShowUiNoteL( _L("SysAp: SW state normal!") ); -#endif - } - - // Allow lights - iSysApLightsController->AllowLightsOn(); - } - - -#endif // SYSAP_USE_STARTUP_UI_PHASE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UiReady() -// -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::UiReady() const - { -#ifdef SYSAP_USE_STARTUP_UI_PHASE - return iSysApStartupController->UiReady(); -#else // SYSAP_USE_STARTUP_UI_PHASE - // if startup UI phase information is not used, global system state normal is handled as UI idle state - return IsStateNormal(); -#endif // SYSAP_USE_STARTUP_UI_PHASE - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::PrepareForShutdownAnimation() -// ---------------------------------------------------------------------------- -void CSysApAppUi::PrepareForShutdownAnimation() - { - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownAnimation() begin") ) ); - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownAnimation() showtime = %d"), iAnimationShowingTime ) ); - if ( iAnimationShowingTime ) - { -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - static_cast(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( EAvkonSIDPowerOffTone ); - CancelGlobalListQuery(); - - if ( iSysApPowerKeyMenuObserver ) - { - iSysApPowerKeyMenuObserver->Cancel(); - } - - // deactivate notifiers before showing the shutdown image - AknNotifierController::CancelAllNotifications(); - AknNotifierController::HideAllNotifications(ETrue); - RWindowGroup groupWin = iCoeEnv->RootWin(); - iCapturedAppskey = groupWin.CaptureKey( EKeyApplication, KModifierMask, KModifierMask ); - iCapturedAppskeyUpAndDowns = groupWin.CaptureKeyUpAndDowns( EStdKeyApplication0, KModifierMask, KModifierMask ); - iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront ); - - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownAnimation() Draw background image" ) ) ); - - ShowShutdownImage( KBackgroundImageID ); - -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownAnimation() Show Shutdown animation" ) ) ); - TInt err(0); - TRAP( err, iSysApShutdownAnimation->StartL( iLastPowerKeyWasShort ) ); - if ( err ) - { - TRACES( RDebug::Print( _L("SysAp: Shutdown animation fails. Error code: %d" ), err ) ); - // Start animation timing immediatily if animation starting fails. - // Otherwise animation will call StartAnimTiming when it is ready. - StartAnimTiming(); - } - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownAnimation() end") ) ); } // ---------------------------------------------------------------------------- -// CSysApAppUi::PrepareForShutdownImage() +// CSysApAppUi::HandleBatteryStatusL // ---------------------------------------------------------------------------- - -void CSysApAppUi::PrepareForShutdownImage() +// +void CSysApAppUi::HandleBatteryStatusL( const TInt aValue ) { - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownImage() START" ) ) ); - - // If RD_STARTUP_ANIMATION_CUSTOMIZATION is enabled, the following actions are always taken in PrepareForShutdownAnimation -#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION - if ( !iAnimationShowingTime ) // actions already taken in PrepareForShutdownAnimation + TRACES( RDebug::Print( _L("CSysApAppUi::HandleBatteryStatusL aValue: %d"), aValue ) ); + + if ( aValue == EBatteryStatusEmpty ) { - static_cast(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( EAvkonSIDPowerOffTone ); - CancelGlobalListQuery(); - - if ( iSysApPowerKeyMenuObserver ) - { - iSysApPowerKeyMenuObserver->Cancel(); - } - - // deactivate notifiers before showing the shutdown image - AknNotifierController::CancelAllNotifications(); - AknNotifierController::HideAllNotifications(ETrue); - RWindowGroup groupWin = iCoeEnv->RootWin(); - iCapturedAppskey = groupWin.CaptureKey( EKeyApplication, KModifierMask, KModifierMask ); - iCapturedAppskeyUpAndDowns = groupWin.CaptureKeyUpAndDowns( EStdKeyApplication0, KModifierMask, KModifierMask ); - } -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - -#ifndef __SYSAP_MODULE_TEST //to make errors during shutdown sequence being seen more easily - iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront ); - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownImage() Show Shutdown image" ) ) ); - ShowShutdownImage( EMbmSysapQgn_startup_screen ); -#endif - TRACES( RDebug::Print( _L("CSysApAppUi::PrepareForShutdownImage() END" ) ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetStatusPaneLauoutL( const TSysApPhoneState aState ) -// ---------------------------------------------------------------------------- - -void CSysApAppUi::SetStatusPaneLayoutL( const TSysApPhoneState aState ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::SetStatusPaneLayoutL aState: %d"), aState ) ); - if( aState == ESysApNormal ) - //Status pane cannot be even visible on Normal mode - { - StatusPane()->MakeVisible( EFalse ); - StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_EMPTY ); - } - else if( aState == ESysApCharging ) - //SysAp's statuspane is visible on Charging mode - { - StatusPane()->MakeVisible( ETrue ); - StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE ); + //Display Recharge Battery note + ShowUiNoteL( ERechargeBatteryNote ); + BatteryEmptyL(); } - else if( aState == ESysApAlarm ) - { - if ( !Layout_Meta_Data::IsLandscapeOrientation() ) - { - // Portrait mode - StatusPane()->MakeVisible( ETrue ); - StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE ); - } - else - { - // Landscape mode - TInt layout = R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE; - // For side softkey devices, use different layout - if (AVKONENV->StatusPaneResIdForCurrentLayout(R_AVKON_STATUS_PANE_LAYOUT_USUAL) == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT) - layout = R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_RIGHT; - else if (AVKONENV->StatusPaneResIdForCurrentLayout(R_AVKON_STATUS_PANE_LAYOUT_USUAL) == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT) - layout = R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_LEFT; - - StatusPane()->MakeVisible( ETrue ); - StatusPane()->SwitchLayoutL( layout ); - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::OkToInitiateShutdown() -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::OkToInitiateShutdown() + else if ( aValue == EBatteryStatusLow ) + { + if ( iSysApPsmController && UiReady() ) + { + iSysApPsmController->BatteryLow( ETrue ); + + + if ( iSysApPsmController->ShowActivateQuery()) + { + // show activation query, replaces the first battery low query + ShowQueryL( ESysApBattLowPowerSavingQuery ); + } + else // default low warning note must be shown + { + // activate partial power save mode on first low warning + iSysApPsmController->DoEnablePartialPsm( ETrue ); // activated on first warning note + //Display Battery Low note. + ShowUiNoteL( EBatteryLowNote ); + } + } + else + { + //Display Battery Low note. + ShowUiNoteL( EBatteryLowNote ); + } + } + + if ( iSysApBatteryInfoController ) { - TInt swState; - RProperty::Get( KPSUidStartup, KPSGlobalSystemState, swState ); - - if( !iShutdownStarted && - swState == ESwStateStartingCriticalApps || - swState == ESwStateSelfTestOK || - swState == ESwStateSecurityCheck || - swState == ESwStateCriticalPhaseOK || - swState == ESwStateEmergencyCallsOnly || - swState == ESwStateCharging || - swState == ESwStateAlarm || - swState == ESwStateNormalRfOn || - swState == ESwStateNormalRfOff || - swState == ESwStateNormalBTSap || - swState == ESwStateFatalStartupError ) - { - iShutdownStarted = ETrue; - return ETrue; - } - else - { - return EFalse; - } + iSysApBatteryInfoController->BatteryStatusUpdated( aValue ); } - -/** - * To check the for an emergency call. - * - * @return ETrue if there is an emergency call active otherwise, EFalse. - */ -TBool IsEmergencyCall() - { - TBool retVal( EFalse ); - TInt err( KErrNone ); - TInt state( 0 ); - - err = RProperty::Get(KPSUidCtsyEmergencyCallInfo, KCTSYEmergencyCallInfo, state ); - if ( err == KErrNone && state ) - { - retVal = ETrue; - } - return retVal; - } + + } // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleCurrentCallStateChangeL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::HandleCurrentCallStateChangeL( TInt aCurrentCallState ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: KUidCurrentCall: %d" ), aCurrentCallState ) ); - - if( iPowerKeyPopupMenuActive ) - { - CancelGlobalListQuery(); - } - - switch ( aCurrentCallState ) - { - case EPSCTsyCallStateRinging: - { - iSysApLightsController->CallComingInL( ETrue ); - // Disable keylock when a call is coming in - if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCradle || iKeyLockOnBeforeAlarm ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateRinging: disable keylock") ) ); - iKeyLockOnBeforeCall = ETrue; - - if ( iKeyLockEnabled || iDeviceLockEnabled ) - { - if ( !iSysApFeatureManager->TouchUnlockStrokeSupported() ) - { - KeyLock().DisableWithoutNote(); - } - } - } - break; - } - - case EPSCTsyCallStateDialling: - { - // Disable keypad lock during an emergency call - // no need to disable the key lock when a call is made using the wireless car-kit - // but if the call is an emergency one then we will disable the keypad lock - if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCradle ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateDialling: disable keylock") ) ); - iKeyLockOnBeforeCall = ETrue; - - if ( IsEmergencyCall() && (iKeyLockEnabled || iDeviceLockEnabled )) - { - KeyLock().DisableWithoutNote(); - } - } - - // Enable signal & network indicators when an emergency call is made in Offline Mode - if( iSysApOfflineModeController->OfflineModeActive() ) - { - // Signal indicators not updated with VoIP call - if ( StateOfProperty(KPSUidCtsyCallInformation, KCTsyCallType) != EPSCTsyCallTypeVoIP) - { - iEmergencyCallActive = ETrue; - UpdateSignalBarsL(); - SetSignalIndicatorL(); - } - } - break; - } - - case EPSCTsyCallStateConnected: - { - if (StateOfProperty(KPSUidCtsyCallInformation, KCTsyCallType) == EPSCTsyCallTypeCSVoice) - { - // Check if GPRS suspended note is required - iCallActivated = ETrue; - HandleGprsNotesL(); - } - if ( iDeviceLockEnabled ) - { - // Enable keylock via autolock emulation if device lock enabled. - // Otherwise e.g. messages can be read using softkeys during ongoing call. - KeyLock().EnableAutoLockEmulation(); - } - break; - } - - case EPSCTsyCallStateNone: - { - // Reset timers in ScreenSaver and Autolock - User::ResetInactivityTime(); - - if ( iEmergencyCallActive ) - { - iEmergencyCallActive = EFalse; - UpdateSignalBarsL( 0 ); - SetSignalIndicatorL(); - } - if ( iKeyLockOnBeforeCall ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateNone: enable keylock") ) ); - iKeyLockOnBeforeCall = EFalse; - if ( !iDeviceLockEnabled ) - { - if ( !iKeyLockOnBeforeCradle && !iKeyLockOnBeforeAlarm && - !iSysApFeatureManager->TouchUnlockStrokeSupported() ) - { - if ( iSysApCenRepController->GetInt( KCRUidCommonTelephonySettings, KSettingsSummaryAfterCall ) == 1 ) - { - KeyLock().EnableWithoutNote(); // Let's not hide "Summary After Call" dialog - } - else - { - KeyLock().EnableKeyLock(); - } - } - } - else - { - KeyLock().EnableAutoLockEmulation(); - } - } - if ( iShowkeypadActivatedNoteAfterSoftReject ) - { - ShowUiNoteL( EKeypadActiveNote ); - iShowkeypadActivatedNoteAfterSoftReject = EFalse; - } - iCallActivated = EFalse; - break; - } - - default: - break; - } - - if ( aCurrentCallState != EPSCTsyCallStateRinging ) - { - iSysApLightsController->CallComingInL( EFalse ); - } - - SetIhfIndicatorL(); - SetHacIndicatorL(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoSwStateNormalConstructionL() +// CSysApAppUi::ShowUiNoteL( const TSysApNoteIds aNote ) const // ---------------------------------------------------------------------------- -void CSysApAppUi::DoSwStateNormalConstructionL() - { - // Let's ensure that the lights will remain on for 15 secs after sw state normal - User::ResetInactivityTime(); - - TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL : START" ) ) ); - - // In case of unexpected reset (e.g. hidden boot) the keylock must be enabled silently. Locking is done - // prior to time-consuming initializations, because otherwise UI is in unlocked state for a few seconds. - if ( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive ) == 1 ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL: enabling keylock") ) ); - KeyLock().EnableWithoutNote(); - } - - // Initiate bearer change observation - iSysApConnectionMonitorObserver = CSysApConnectionMonitorObserver::NewL( *this ); - - TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL: trying CSysApSsSettingsObserver::NewL()") ) ); - iSysApSsSettingsObserver = CSysApSsSettingsObserver::NewL( *this ); - - TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL: trying new ( ELeave ) CSysApPowerKeyMenuObserver") ) ); - iSysApPowerKeyMenuObserver = new( ELeave ) CSysApPowerKeyMenuObserver( *this ); - - TRACES( RDebug::Print( _L("SysAp: trying CSystemLock::NewL" ) ) ); - iSysApSystemLock = CSystemLock::NewL(); - - iSysApCenRepCallForwardingObserver = CSysApCenRepCallForwardingObserver::NewL( *this ); - - iSysApCenRepMsgWaitingObserver = CSysApCenRepMsgWaitingObserver::NewL( *this ); - - - if ( iSysApFeatureManager->Supported( KSysApFeatureIdBatteryInfoPopup ) ) - { - iSysApBatteryInfoController = CSysApBatteryInfoController::NewL( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsConf, - KCoreAppUIsBatteryInformationLowThreshold ) ); - } - - - TRACES( RDebug::Print( _L("CSysApAppUi::DoSwStateNormalConstructionL : END" ) ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoSimChangedFromPreviousBootL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::DoSimChangedFromPreviousBootL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::DoSimChangedFromPreviousBootL: iSimChangedDone=%d" ), iSimChangedDone ) ); - - if ( !iSimChangedDone ) - { - iSimChangedDone = ETrue; - CSysApSimChanged* simChanged = CSysApSimChanged::NewL( *this, iEikonEnv->FsSession() ); - CleanupStack::PushL( simChanged ); - simChanged->HandleSimChangedL(); - CleanupStack::PopAndDestroy( simChanged ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::CancelWaitNote() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::CancelWaitNote() +void CSysApAppUi::ShowUiNoteL( const TSysApNoteIds aNote ) const { - TRACES( RDebug::Print( _L("CSysApAppUi::CancelWaitNote" ) ) ); - if ( iSysApWaitNote ) - { - iSysApWaitNote->Cancel(); - delete iSysApWaitNote; - iSysApWaitNote = NULL; - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::CancelGlobalListQuery() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::CancelGlobalListQuery() - { - TRACES( RDebug::Print( _L("CSysApAppUi::CancelGlobalListQuery" ) ) ); - if ( iGlobalListQuery ) - { - iGlobalListQuery->CancelListQuery(); - delete iGlobalListQuery; - iGlobalListQuery = NULL; - } - } - -#ifndef RD_MULTIPLE_DRIVE -// ---------------------------------------------------------------------------- -// CSysApAppUi::MountMMC() -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::MountMMC() - { - TRACES( RDebug::Print( _L("CSysApAppUi::MountMMC") ) ); - TInt err ( KErrNotSupported ); - if ( iSysApFeatureManager->MmcSupported() ) - { -#ifdef __WINS__ // Let's sleep a second in WINS - User::After( 1000000 ); -#endif - err = iEikonEnv->FsSession().MountFileSystem( KFSName, KMMCDrive ); - TRACES( RDebug::Print( _L("CSysApAppUi::MountMMC: RFs::MountFileSystem() returned: %d"), err ) ); - if ( err == KErrInUse ) - { - User::After( 1000000 ); - err = iEikonEnv->FsSession().MountFileSystem( KFSName, KMMCDrive ); - TRACES( RDebug::Print( _L("CSysApAppUi::MountMMC: RFs::MountFileSystem() returned: %d"), err ) ); - } - } - return err; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DismountMMC() -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::DismountMMC() - { - TRACES( RDebug::Print( _L("CSysApAppUi::DismountMMC") ) ); -#ifdef __WINS__ // Let's sleep a second in WINS - User::After( 1000000 ); -#endif - - TInt err ( KErrNotSupported ); - if ( iSysApFeatureManager->MmcSupported() ) - { - err = iEikonEnv->FsSession().DismountFileSystem( KFSName, KMMCDrive ); - TRACES( RDebug::Print( _L("CSysApAppUi::DismountMMC: RFs::DismountFileSystem() returned: %d"), err ) ); - } - return err; - } + TRACES( RDebug::Print( _L("CSysApAppUi::ShowUiNoteL aNote: %d"), aNote ) ); + + TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); -// ---------------------------------------------------------------------------- -// CSysApAppUi::EjectMMCL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::EjectMMCL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::EjectMMCL") ) ); - iMMCEjectUsed = ETrue; - iMMCPowerMenuEjectUsed = ETrue; - iTimeToKill = EFalse; - iApplicationScanningRoundNumber = 0; - CloseUIAppsInHotSwapL(); - } - -#else // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::EjectMMCL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::EjectMMCL() - { - // Called from eject confirm query, check drive inserted before start - TInt insertedIndex( CSysApDriveList::Find( - iInsertedMemoryCards, iDriveToEject ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::EjectMMCL: iMMCEjectUsed: %d, drive: %d, index: %d "), - iMMCEjectUsed, iDriveToEject, insertedIndex ) ); - - if ( insertedIndex != KErrNotFound ) - { - iSysApDriveList->MarkDriveToEject( - iDriveToEject, CSysApDriveList::EEjectFromMenu ); - iSysApDriveEjectHandler->StartEject(); - } - iMMCEjectUsed = EFalse; - } - -#endif // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DisconnectBtSap() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::DisconnectBtSap() - { - TRACES( RDebug::Print( _L("CSysApAppUi::DisconnectBtSap") ) ); - iSysApBtSapController->Disconnect(); - } - -#ifndef RD_MULTIPLE_DRIVE -// ---------------------------------------------------------------------------- -// CSysApAppUi::RunUnlockNotifierL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::RunUnlockNotifierL( TSysApMemoryCardStatus aMemoryCardStatus ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL: START") ) ); - if ( iSysApFeatureManager->MmcSupported() ) - { - if ( UiReady() ) + if( UiReady() || swState == ESwStateSecurityCheck) + { + switch ( aNote ) { - TSysApMemoryCardStatus memoryCardStatus; - if ( aMemoryCardStatus == ESysApMemoryCardStatusNotKnown ) + case EBatteryLowNote: + { + _LIT(KPowerPressKey,"Battery low"); + HBufC* aString = HBufC16::NewLC(100); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString + } + break; + case EBatteryFullNote: { - memoryCardStatus = iSysApMMCObserver->MemoryCardStatus(); + _LIT(KPowerPressKey,"Battery full"); + HBufC* aString = HBufC16::NewLC(100); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString + } + break; + case ERechargeBatteryNote: + { + iSysApLightsController->BatteryEmptyL( ETrue ); + _LIT(KPowerPressKey,"Battery empty. Recharge"); + HBufC* aString = HBufC16::NewLC(100); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString } - else + break; + case ENotChargingNote: { - memoryCardStatus = aMemoryCardStatus; + _LIT(KPowerPressKey,"Not charging"); + HBufC* aString = HBufC16::NewLC(100); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString } - - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL: memoryCardStatus=%d"), memoryCardStatus ) ); - - switch ( memoryCardStatus ) + break; + case EBatteryFullUnplugChargerNote: { - case ESysApMemoryCardInserted: - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL MMC inserted") ) ); - if ( aMemoryCardStatus == ESysApMemoryCardInserted ) - { - RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 ); - } - break; - case ESysApMemoryCardLocked: - { - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL MMC locked") ) ); - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - TInt callState = StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ); - - if ( (! ( iDeviceLockEnabled || iKeyLockEnabled ) ) && - callState != EPSCTsyCallStateRinging && // We don't want to see the MMC passwd query - callState != EPSCTsyCallStateAlerting ) // when the user is e.g. making an emergency call - { - if ( iSysApFeatureManager->MemoryCardLockSupported() ) - { - if ( ! iMemoryCardDialog ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL: ACTIVATE MMC passwd query") ) ); - CAknMemoryCardDialog* mmcDialog = CAknMemoryCardDialog::NewLC( this ); - iMemoryCardDialog = mmcDialog; // temporary variable used for hiding codescanner error - iMemoryCardDialog->SetSelfPointer( &iMemoryCardDialog ); - iMemoryCardDialog->UnlockCardLD(); // when UnlockCardLD completes it calls UnlockComplete() - } - } - else - { - // Since locked cards are not supported, notify user that card is locked. - ShowQueryL( ESysApMemoryCardLockedNote ); - } - } - } - break; - - case ESysApMemoryCardNotInserted: - default: - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL MMC not inserted") ) ); - if ( aMemoryCardStatus == ESysApMemoryCardNotInserted ) - { - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - } + /* + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + iSysApLightsController->BatteryEmptyL( ETrue ); + _LIT(KunplugCharger,"txt_power_dpopinfo_unplug_charger_to_save_energy"); + HBufC* unplugCharger = HbTextResolverSymbian::LoadL(KunplugCharger); + _LIT(KbatteryFull,"txt_power_management_dpophead_100_full"); + HBufC* batteryFull = HbTextResolverSymbian::LoadL(KbatteryFull); + CHbDeviceNotificationDialogSymbian::NotificationL(KbatteryFullIcon,*unplugCharger,*batteryFull); + */ + + iSysApLightsController->BatteryEmptyL( ETrue ); + _LIT(KPowerPressKey,"Charging complete. Unplug charger to save energy."); + HBufC* aString = HBufC16::NewLC(200); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString + } + break; + case EUnplugChargerNote: + { + _LIT(KPowerPressKey,"Unplug charger from power supply to save energy"); + HBufC* aString = HBufC16::NewLC(250); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KPowerPressKey); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString } + break; + default: + break; } } - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL: END") ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UnlockComplete() from MAknMemoryCardDialogObserver -// ---------------------------------------------------------------------------- - -void CSysApAppUi::UnlockComplete( TInt aResult ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::UnlockComplete result: %d"), aResult ) ); - if ( aResult == KErrNone ) - { - RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 ); - } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::MMCStatusChangedL() from MSysApMemoryCardObserver -// ---------------------------------------------------------------------------- - -void CSysApAppUi::MMCStatusChangedL() - { - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL START: iMMCInserted: %d, iMMCEjectUsed: %d, iHideFirstBeep: %d, iHideNextBeep: %d" ), iMMCInserted, iMMCEjectUsed, iHideFirstBeep, iHideNextBeep ) ); - - if ( iSysApFeatureManager->MmcSupported() && !iShutdownStarted ) - { - TSysApMemoryCardStatus memoryCardStatus = iSysApMMCObserver->MemoryCardStatus(); - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL memoryCardStatus=%d" ), memoryCardStatus ) ); - - switch ( memoryCardStatus ) - { - case ESysApMemoryCardInserted: - case ESysApMemoryCardLocked: - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL: MMC drive mounted" ) ) ); - if ( ! iMMCInserted ) // MMC was not inserted before - { - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL: MMC newly inserted" ) ) ); - CancelWaitNote(); // just to be sure, the user might keep on closing and opening the MMC latch - // An MMC has been newly inserted, so play a sound and check if its password protected - - if ( UiReady() ) - { - if ( !iHideFirstBeep && !iHideNextBeep ) // starting up - { - Beep(); - // Switch lights on - iSysApLightsController->MemoryCardInsertedL(); - } - iHideNextBeep = EFalse; - } - - iMMCPowerMenuEjectUsed = EFalse; - iMMCEjectUsed = EFalse; - iMMCInserted = ETrue; - - // No need to show ESysApRemoveMmcNote after MMC already mounted - if ( iSysApConfirmationQuery ) - { - if ( iSysApConfirmationQuery->CurrentQuery() == ESysApRemoveMmcNote ) - { - iSysApConfirmationQuery->Cancel(); - } - } - - // Check if the MMC is locked and unlock it if necessary - RunUnlockNotifierL( memoryCardStatus ); - } - break; - default: - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL: MMC drive not mounted" ) ) ); - delete iMemoryCardDialog; // sets itself to null - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - if ( iMMCInserted ) - { - // No need to show ESysApEjectMmcQuery after MMC already removed - if ( iSysApConfirmationQuery ) - { - if ( iSysApConfirmationQuery->CurrentQuery() == ESysApEjectMmcQuery ) - { - iSysApConfirmationQuery->Cancel(); - } - } - - iMMCInserted = EFalse; - - TInt propertyValue( StateOfProperty( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality ) ); - if ( !iMMCEjectUsed && propertyValue != KUsbPersonalityIdMS ) - { - // if USB file transfer active, do not close applications - // if eject selected in MMC App, MMC App takes care of the following and - // if eject selected from powerkeymenu, applications have already been shutdown - iTimeToKill = EFalse; - iApplicationScanningRoundNumber = 0; - CloseUIAppsInHotSwapL(); - } - } - else - { - // If MMC was not previously inserted and eject was chosed from power key menu, attempt to remount. - if ( iMMCPowerMenuEjectUsed ) - { - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL: Attempt to remount" ) ) ); - MountMMC(); - // If mount was successful, unnecessary note will be canceled in insert notification handling. - } - } - break; - } - - // Update memory card indicator status - SetMemoryCardIndicatorL(); - } - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCStatusChangedL END: iMMCInserted: %d, iMMCEjectUsed: %d, iHideFirstBeep: %d, iHideNextBeep: %d" ), iMMCInserted, iMMCEjectUsed, iHideFirstBeep, iHideNextBeep ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowMMCDismountedDialogL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShowMMCDismountedDialogL() - { - TInt propertyValue( StateOfProperty( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality ) ); - - // Do not show any note if USB file transfer is active. - if ( propertyValue != KUsbPersonalityIdMS ) - { - if ( iSysApFeatureManager->MemoryCardHatchSupported() ) - { // MMC hatch has been opened and MMC has been dismounted - TRACES( RDebug::Print( _L( "CSysApAppUi::ShowMMCDismountedDialogL: Show note: Remove MMC and press OK." ) ) ); - ShowQueryL( ESysApRemoveMmcNote ); - } - else - { - // MMC has been removed and dismounted - TRACES( RDebug::Print( _L( "CSysApAppUi::ShowMMCDismountedDialogL: Show note: You might have lost some data." ) ) ); - // No confirmation but let's set this true to enable MMC passwd query - ShowUiNoteL( EMemoryCardRemovedWithoutEjectNote ); - } - } - else - { - TRACES( RDebug::Print( _L( "CSysApAppUi::ShowMMCDismountedDialogL: No note shown, USB file transfer caused dismount." ) ) ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::MMCDismountedDialogConfirmed -// ---------------------------------------------------------------------------- - -void CSysApAppUi::MMCDismountedDialogConfirmed() - { - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCDismountedDialogConfirmed") ) ); - - // Try to remount just in case when eject was chosen from power key menu - if ( iMMCPowerMenuEjectUsed ) - { - iMMCPowerMenuEjectUsed = EFalse; - - if ( MountMMC() == KErrLocked ) // In case a locked card was not removed after all - { - TRAPD( err, MMCStatusChangedL() ); // This will update power menu and memory card icon. Also memory card password is requeried. - if ( err != KErrNone ) - { - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCDismountedDialogConfirmed: MMCStatusChangedL failed, err=%d"), err ) ); - } - } - } - - } - -#else // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::MMCInsertedL -// ---------------------------------------------------------------------------- - -void CSysApAppUi::MMCInsertedL() - { - TRACES( RDebug::Print( _L( "CSysApAppUi::MMCInsertedL") ) ); - - if ( iSysApFeatureManager->MmcSupported() && !iShutdownStarted ) - { - TBool normalState( UiReady() ); - - if ( normalState ) - { - TInt defaultMemoryCard( iSysApDriveList->DefaultMemoryCard() ); - TSysApMemoryCardStatus memoryCardStatus( iSysApDriveList->MemoryCardStatus( defaultMemoryCard ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCInsertedL: drive: %d, memoryCardStatus: %d" ), defaultMemoryCard, memoryCardStatus ) ); - - switch ( memoryCardStatus ) - { - case ESysApMemoryCardInserted: // Fall through - case ESysApMemoryCardLocked: - { - // Reset eject and unlock of inserted memory card - iSysApDriveList->ResetDriveToEject( defaultMemoryCard ); - iSysApDriveList->ResetDriveUnlockQueryShown( defaultMemoryCard ); - - CancelWaitNote(); - - if ( memoryCardStatus == ESysApMemoryCardInserted ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCInsertedL: memoryCardStatus ESysApMemoryCardInserted: %d" ), memoryCardStatus ) ); - RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 ); - } - else - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCInsertedL: memoryCardStatus ESysApMemoryCardLocked: %d" ), memoryCardStatus ) ); - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - } - break; - } - case ESysApMemoryCardNotInserted: - { - // Always reset eject and unlock of removed memory card - TBool isEject( iSysApDriveList->IsDriveToEject( defaultMemoryCard ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCInsertedL: isEject: %d, drive: %d" ), - isEject, defaultMemoryCard ) ); - - iSysApDriveList->ResetDriveToEject( defaultMemoryCard ); - iSysApDriveList->ResetDriveUnlockQueryShown( defaultMemoryCard ); - - TRACES( RDebug::Print( - _L( "SysApAppUi::MMCInsertedL: memoryCardStatus ESysApMemoryCardNotInserted: %d" ), memoryCardStatus ) ); - - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - break; - } - case ESysApMemoryCardStatusNotKnown: // Fall through - default: - { - break; - } - } - RunUnlockNotifierL(); - } - } - } - - -// ---------------------------------------------------------------------------- -// CSysApAppUi::RunUnlockNotifierL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::RunUnlockNotifierL() - { - TRACES( RDebug::Print( - _L("CSysApAppUi::RunUnlockNotifierL: START iDeviceLockEnabled: %d, iKeyLockEnabled: %d" ), - iDeviceLockEnabled, iKeyLockEnabled ) ); - - if ( !iSysApFeatureManager->MmcSupported() || - iDeviceLockEnabled || - iKeyLockEnabled || - !UiReady() ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL: END") ) ); - return; - } - - // We don't want to see the MMC passwd query - // when the user is e.g. making an emergency call - TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ); - if ( callState != EPSCTsyCallStateRinging && - callState != EPSCTsyCallStateAlerting ) - { - iSysApDriveUnlockHandler->StartUnlock(); - } - - TRACES( RDebug::Print( - _L("CSysApAppUi::RunUnlockNotifierL: END callState: %d"), callState ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::MMCStatusChangedL() from MSysApMemoryCardObserver -// ---------------------------------------------------------------------------- - -void CSysApAppUi::MMCStatusChangedL( TInt aDrive ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL START: MMCCount: %d, iMMCEjectUsed: %d" ), - iInsertedMemoryCards.Count(), iMMCEjectUsed ) ); - - if ( iShutdownStarted || !iSysApFeatureManager->MmcSupported() ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL iShutdownStarted: %d END" ), - iShutdownStarted ) ); - return; - } - - TBool normalState( UiReady() ); - - TInt defaultMemoryCard( iSysApDriveList->DefaultMemoryCard() ); - TSysApMemoryCardStatus memoryCardStatus( iSysApDriveList->MemoryCardStatus( aDrive ) ); - TInt insertedIndex( CSysApDriveList::Find( iInsertedMemoryCards, aDrive ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL: normalState: %d, index: %d, drive: %d, memoryCardStatus: %d" ), - normalState, insertedIndex, aDrive, memoryCardStatus ) ); - - switch ( memoryCardStatus ) - { - case ESysApMemoryCardInserted: // Fall through - case ESysApMemoryCardLocked: - { - if ( insertedIndex == KErrNotFound ) // Not inserted before - { - // Reset eject and unlock of inserted memory card - iSysApDriveList->ResetDriveToEject( aDrive ); - iSysApDriveList->ResetDriveUnlockQueryShown( aDrive ); - - CancelWaitNote(); - - if ( aDrive == defaultMemoryCard ) - { - if ( memoryCardStatus == ESysApMemoryCardInserted ) - { - RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 ); - } - else - { - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - } - } - - if ( normalState ) - { - // Ignore extra beep from USB file transfer - TBool ignoreBeep( - iSysApDriveList->IsDriveInsertBeepIgnored( aDrive ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL: ignoreBeep: %d, drive: %d" ), - ignoreBeep, aDrive ) ); - - if ( !ignoreBeep ) - { - Beep(); - iSysApLightsController->MemoryCardInsertedL(); - } - - iSysApDriveList->ResetDriveInsertBeepIgnored( aDrive ); - - // Keep ignoring extra beep if USB file transfer is active - TInt propertyValue( StateOfProperty( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL: usbState: %d" ), propertyValue ) ); - - if ( propertyValue == KUsbPersonalityIdMS ) - { - iSysApDriveList->MarkDriveInsertBeepIgnored( aDrive ); - } - } - - if ( iDriveToDismount == aDrive && iSysApConfirmationQuery ) - { - if ( iSysApConfirmationQuery->CurrentQuery() == ESysApRemoveMmcNote ) - { - // User put back ejected memory card or did not remove it - iSysApConfirmationQuery->Cancel(); - } - } - RunUnlockNotifierL(); - } - break; - } - case ESysApMemoryCardNotInserted: - { - // Always reset eject and unlock of removed memory card - TBool isEject( iSysApDriveList->IsDriveToEject( aDrive ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL: isEject: %d, drive: %d" ), - isEject, aDrive ) ); - - iSysApDriveList->ResetDriveToEject( aDrive ); - iSysApDriveList->ResetDriveUnlockQueryShown( aDrive ); - - if ( insertedIndex != KErrNotFound ) // Inserted before - { - if ( memoryCardStatus == ESysApMemoryCardNotInserted ) - { - // Reset extra beep ignore if memory card was removed without eject - iSysApDriveList->ResetDriveInsertBeepIgnored( aDrive ); - } - - CancelGlobalListQuery(); // Cancel power menu - - if ( aDrive == defaultMemoryCard ) - { - RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 ); - } - - if ( iSysApConfirmationQuery ) - { - if ( iSysApConfirmationQuery->CurrentQuery() == ESysApEjectMmcQuery ) - { - // User removed memory card too early - iSysApConfirmationQuery->Cancel(); - // Allow application closing to execute. - // Also FileManager is closed in this case, regardless where the eject was initiated from. - iMMCEjectUsed = EFalse; - } - } - - // Stop unlock of removed memory card - iSysApDriveUnlockHandler->StopUnlock( aDrive ); - - if ( !iMMCEjectUsed && !isEject ) - { - TInt propertyValue( StateOfProperty( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL: usbState: %d" ), propertyValue ) ); - - if ( propertyValue != KUsbPersonalityIdMS ) - { - if ( iSysApFeatureManager->MemoryCardHatchSupported() ) - { - // Store drive removed without eject and start eject handling - iSysApDriveList->MarkDriveToEject( - aDrive, CSysApDriveList::EEjectRemovedWithoutEject ); - iSysApDriveEjectHandler->StartEject(); - } - else - { - // Just show the note - ShowUiNoteL( EMemoryCardRemovedWithoutEjectNote ); - } - } - } - iMMCEjectUsed = EFalse; - } - break; - } - case ESysApMemoryCardStatusNotKnown: // Fall through - default: - { - break; - } - } - - // Update inserted memory cards - iSysApDriveList->GetMemoryCardsL( - iInsertedMemoryCards, CSysApDriveList::EIncludeInserted ); - - // Update memory card indicator status - SetMemoryCardIndicatorL(); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCStatusChangedL END: MMCCount: %d, iMMCEjectUsed: %d" ), - iInsertedMemoryCards.Count(), iMMCEjectUsed ) ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowMMCDismountedDialogL() -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::ShowMMCDismountedDialogL( - TInt aDrive, CSysApDriveList::TDriveEjectType aEjectType ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::ShowMMCDismountedDialogL: aDrive: %d, aEjectType: %d" ), - aDrive, aEjectType ) ); - - TBool ret( EFalse ); - iDriveToDismount = aDrive; - HBufC* driveName = iSysApDriveList->GetFormattedDriveNameLC( - aDrive, - R_QTN_EJECT_REMOVE_MEMORY_INFO ); - - if ( aEjectType == CSysApDriveList::EEjectFromMenu ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::ShowMMCDismountedDialogL: Show note: Remove MMC and press OK...." ) ) ); - ShowQueryL( ESysApRemoveMmcNote, *driveName ); - ret = ETrue; - } - else - { - // Memory card was removed without eject - TInt propertyValue( StateOfProperty( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality ) ); - - // Do not show any note if USB file transfer is active. - if ( propertyValue != KUsbPersonalityIdMS ) - { - if ( iSysApFeatureManager->MemoryCardHatchSupported() ) - { - // MMC hatch has been opened and MMC has been dismounted - TRACES( RDebug::Print( - _L( "CSysApAppUi::ShowMMCDismountedDialogL: Show note: Remove MMC and press OK." ) ) ); - ShowQueryL( ESysApRemoveMmcNote, *driveName ); - ret = ETrue; - } - else - { - iSysApDriveList->ResetDrivesToEject(); - - // MMC has been removed and dismounted - TRACES( RDebug::Print( _L( - "CSysApAppUi::ShowMMCDismountedDialogL: Show note: You might have lost some data." ) ) ); - - // No confirmation but let's set this true to enable MMC passwd query - ShowUiNoteL( EMemoryCardRemovedWithoutEjectNote ); - } - } - else - { - iSysApDriveList->ResetDrivesToEject(); - TRACES( RDebug::Print( - _L( "CSysApAppUi::ShowMMCDismountedDialogL: No note shown, USB file transfer caused dismount." ) ) ); - } - } - - CleanupStack::PopAndDestroy( driveName ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::ShowMMCDismountedDialogL: ret: %d" ), ret ) ); - - return ret; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::MMCDismountedDialogConfirmed -// ---------------------------------------------------------------------------- - -void CSysApAppUi::MMCDismountedDialogConfirmed() - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::MMCDismountedDialogConfirmed: iDriveToDismount: %d" ), - iDriveToDismount ) ); - - // Try remount to check if drive was put back - iSysApDriveList->MountDrive( iDriveToDismount ); - if ( !iSysApDriveEjectHandler->CompleteDismount( iDriveToDismount ) ) - { - // When ready, check for locked memory cards and update indicators - TRAP_IGNORE( SetMemoryCardIndicatorL() ); - TRAP_IGNORE( RunUnlockNotifierL() ); - } - } - -#endif // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::EjectStarted() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::EjectStarted( TBool ejectStarted ) - { - TRACES( RDebug::Print( _L( "CSysApAppUi::EjectStarted" ) ) ); - iMMCEjectUsed = ejectStarted; - -#ifndef RD_MULTIPLE_DRIVE - iFileManagerCloseDisabled = ejectStarted; -#endif // RD_MULTIPLE_DRIVE -} - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DoLightsTimeoutChangedL -// ---------------------------------------------------------------------------- -void CSysApAppUi::DoLightsTimeoutChangedL( const TInt aTimeout ) - { - iSysApLightsController->DoLightsTimeoutChangedL( aTimeout ); - } - -#ifdef __SYSAP_MODULE_TEST - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ModuleTestShowUiNoteL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ModuleTestShowUiNoteL( const TDesC& noteText ) const - { - CAknGlobalNote* note = CAknGlobalNote::NewLC(); - note->SetTone( EAvkonSIDNoSound ); - note->ShowNoteL( EAknGlobalInformationNote, noteText ); - CleanupStack::PopAndDestroy(); // note - } - -#endif - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowShutdownNoteL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::ShowShutdownNoteL() - { - TRACES( RDebug::Print( _L( "CSysApAppUi::ShowShutdownNoteL") ) ); - ShowUiNoteL( EShutdownNote ); - User::After( KTimeToShowShutdownNote ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::Beep() -// ---------------------------------------------------------------------------- -void CSysApAppUi::Beep() - { - static_cast(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( EAvkonSIDInformationTone ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SimSupported() -// ---------------------------------------------------------------------------- -TBool CSysApAppUi::SimSupported() - { - return iSysApFeatureManager->SimSupported(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::IsStateNormal() -// -// ---------------------------------------------------------------------------- -TBool CSysApAppUi::IsStateNormal() const - { - TInt state; - TInt errorCode = - RProperty::Get( KPSUidStartup, KPSGlobalSystemState, state ); - if ( errorCode == KErrNone ) - { - return state == ESwStateNormalRfOn || - state == ESwStateNormalRfOff || - state == ESwStateNormalBTSap; - } - else - { - TRACES( RDebug::Print( _L( "CSysApAppUi::IsStateNormal: Failed to read global system state, error code %d." ), errorCode ) ); - return EFalse; - } - } // ---------------------------------------------------------------------------- // CSysApAppUi::BatteryEmptyL() @@ -5743,761 +1982,222 @@ iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive, 0 ); } -// ---------------------------------------------------------------------------- -// CSysApAppUi::Max() -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::Max( const TInt aA, const TInt aB, const TInt aC ) - { - TInt max( aA ); - if ( aB > max ) - { - max = aB; - } - if ( aC > max ) - { - max = aC; - } - return max; - } // ---------------------------------------------------------------------------- -// CSysApAppUi::SetStarterState() -// ---------------------------------------------------------------------------- - -TInt CSysApAppUi::SetStarterState( const RStarterSession::TGlobalState aState ) - { - if ( iSysApStartupController->GlobalStateChangeAllowed( aState ) ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::SetStarterState: aState=%d" ), aState ) ); - return StarterSession().SetState( aState ); - } - else - { - TRACES( RDebug::Print( _L("CSysApAppUi::SetStarterState: aState=%d - not allowed" ), aState ) ); - return KErrNone; - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::GetBtSapDeviceNameL() -// ---------------------------------------------------------------------------- - -HBufC* CSysApAppUi::GetBtSapDeviceNameL() - { - return iSysApBtSapController->GetBtSapDeviceNameL(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowAlarmIndicatorL() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShowAlarmIndicatorL( TBool aShowIndicator ) - { - if ( aShowIndicator) - { - SetIndicatorStateL( EAknIndicatorAlarmClock, EAknIndicatorStateOn ); - } - else - { - SetIndicatorStateL( EAknIndicatorAlarmClock, EAknIndicatorStateOff ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SimulateFlipKeyEventL() +// CSysApAppUi::ShowQueryL() // ---------------------------------------------------------------------------- -void CSysApAppUi::SimulateFlipKeyEventL( TBool aFlipOpen ) +void CSysApAppUi::ShowQueryL( const TSysApConfirmationQueryIds /* aQueryId */, const TDesC& /* aValue */) { - TRACES( RDebug::Print( _L("CSysApAppUi::SimulateFlipKeyEventL: aFlipOpen: %d" ), aFlipOpen ) ); - - /* - Flip key is constructed when a flip notification via Pub&Sub is received. The reason behind - providing this as a key event is to enable unified handling of keys also with flip, and because - flip is captured&consumed by Avkon it is not possible to capture flip key events directly - from default handler/plugins. - */ - - TKeyEvent flipEvent; - flipEvent.iCode = aFlipOpen ? EKeyFlipOpen : EKeyFlipClose; - flipEvent.iScanCode = 0; - flipEvent.iModifiers = 0; - flipEvent.iRepeats = 0; - - HandleKeyEventL( flipEvent, EEventKey ); + // do nothing } -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetFlipOpenL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::SetFlipOpenL( TBool aFlipOpen ) - { - iSysApLightsController->SetFlipOpenL( aFlipOpen ); - } // ---------------------------------------------------------------------------- -// CSysApAppUi::SetGripOpenL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::SetGripOpenL( TBool aGripOpen ) - { - iSysApLightsController->SetGripOpenL( aGripOpen ); - } - +// CSysApAppUi::HandleChargingStatusL // ---------------------------------------------------------------------------- -// CSysApAppUi::SetNetworkConnectionAllowed() -// ---------------------------------------------------------------------------- - -void CSysApAppUi::SetNetworkConnectionAllowed( TCoreAppUIsNetworkConnectionAllowed aNetworkConnectionAllowed ) +// +void CSysApAppUi::HandleChargingStatusL( const TInt aValue ) { - TRACES( RDebug::Print( _L("CSysApAppUi::SetNetworkConnectionAllowed: status: %d" ), aNetworkConnectionAllowed ) ); - - iSysApCenRepController->SetInt( KCRUidCoreApplicationUIs, KCoreAppUIsNetworkConnectionAllowed, (TInt) aNetworkConnectionAllowed ); + TRACES( RDebug::Print( _L("CSysApAppUi::HandleChargingStatusL aValue: %d"), aValue ) ); + + TBool showNote( ETrue ); + + UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - // Also set the Symbian PS key used for the same purpose: - RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, aNetworkConnectionAllowed ? ESAPhoneOn : ESAPhoneOff); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::GetTelServerL() -// ---------------------------------------------------------------------------- - -RTelServer* CSysApAppUi::GetTelServer() - { - if ( iSysApEtelConnector ) + if ( iSysApPsmController && UiReady() ) + { + if ( iCharging && !iSysApPsmController->ChargerConnected() ) // first time after charger connection + { + iSysApPsmController->ConnectCharger( ETrue ); + if ( iSysApPsmController->ShowDeactivateQuery() ) + { + ShowQueryL( ESysApBattChargingPowerSavingQuery ); + // Query is on the display. Don't show the note. + showNote = EFalse; + } + else + { + iSysApPsmController->DoEnablePartialPsm( EFalse ); + } + } + else if ( aValue == EChargingStatusNotConnected ) + { + iSysApPsmController->ConnectCharger( EFalse ); + } + } + if( showNote ) { - return iSysApEtelConnector->GetTelServer(); - } - else - { - return NULL; + HandleChargerNotesL( aValue ); } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::CoverDisplaySupported() -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::CoverDisplaySupported() - { - return iSysApFeatureManager->CoverDisplaySupported(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::StarterSession() -// ---------------------------------------------------------------------------- - -RStarterSession& CSysApAppUi::StarterSession() - { - if ( !iStarterSession.Handle() ) - { - // All server connections are tried to be made KTriesToConnectServer times because occasional - // fails on connections are possible at least on some servers - TRACES( RDebug::Print( _L("CSysApAppUi::StarterSession: trying RStarterSession::Connect()") ) ); - TInt thisTry = 0; - TInt err; - while ( ( err = iStarterSession.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer ) - { - User::After( KTimeBeforeRetryingServerConnection ); - } - - if ( err != KErrNone ) - { - // What do in error case? - TRACES( RDebug::Print( _L("CSysApAppUi::StarterSession: RStarterSession::Connect() failed with %d"), err ) ); - } - } - - return iStarterSession; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::KeyLock() -// ---------------------------------------------------------------------------- - -RAknKeylock2& CSysApAppUi::KeyLock() - { - if ( !iKeyLock.Handle() ) - { - // All server connections are tried to be made KTriesToConnectServer times because occasional - // fails on connections are possible at least on some servers - TInt thisTry = 0; - TInt err; - - TRACES( RDebug::Print( _L("CSysApAppUi::KeyLock: trying RAknKeylock2::Connect()") ) ); - thisTry = 0; - while ( ( err = iKeyLock.Connect() ) != KErrNone && ( thisTry++ ) <= KTriesToConnectServer ) - { - User::After( KTimeBeforeRetryingServerConnection ); - } - - if ( err != KErrNone ) - { - // What do in error case? - TRACES( RDebug::Print( _L("CSysApAppUi::KeyLock: RAknKeylock2::Connect() failed with %d"), err ) ); - } - } - - return iKeyLock; - } // ---------------------------------------------------------------------------- -// CSysApAppUi::CenRepController() -// ---------------------------------------------------------------------------- - -CSysApCenRepController& CSysApAppUi::CenRepController() - { - __ASSERT_ALWAYS( iSysApCenRepController, User::Panic( _L("CSysApAppUi::CenRepController"), KErrBadHandle ) ); - - return *iSysApCenRepController; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ExecCommandL +// CSysApAppUi::HandleChargerNotesL() // ---------------------------------------------------------------------------- -// -void CSysApAppUi::ExecCommandL( TSysapCommand aCommand ) +void CSysApAppUi::HandleChargerNotesL( const TInt aValue ) { - ExecCommandL( aCommand, KNullDesC8 ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ExecCommandL -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::ExecCommandL( TSysapCommand aCommand, const TDesC8& aParam ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ExecCommandL: aCommand=%d"), aCommand ) ); - - switch ( aCommand ) + TBool showNote(StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) != EPSCTsyCallStateRinging); + if ( aValue == EChargingStatusCharging ) + { + iSysApLightsController->BatteryEmptyL( EFalse ); + TRACES( RDebug::Print( _L("SysAp: charger connected") ) ); + iSysApLightsController->ChargerConnectedL( ETrue ); + ShowChargingNoteL(); + } + //Display Not Charging note + else if ( aValue == EChargingStatusError ) + { + if(showNote) + { + ShowUiNoteL( ENotChargingNote ); + } + } + else if ( aValue == EChargingStatusChargingComplete ) { - case EResetKeyguardState: // reset the internal keyguard flags of the SysAp, except for iKeyLockOnBeforeCradle - iKeyLockOnBeforeCall = EFalse; - iKeyLockOnBeforeAlarm = EFalse; - break; - - case ECancelPowermenu: // hide power menu if it is visible - if( iPowerKeyPopupMenuActive ) - { - CancelGlobalListQuery(); - } - break; - - case EUpdateLights: // apply key specific light handling + iSysApLightsController->ChargingCompleteL(); + + TSysApNoteIds note( EBatteryFullNote ); + + if ( !iSysApUsbChargerDetector.HostOnlyUsbChargingUsed() && + iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) ) + { + note = EBatteryFullUnplugChargerNote; + } + iSysApUsbChargerDetector.Reset(); + if(showNote) { - TUpdateLightsBuf lightBuf; - lightBuf.Copy( aParam ); - - switch ( lightBuf() ) + ShowUiNoteL( note ); + } + } + else if ( aValue == EChargingStatusNotConnected ) + { + TRACES( RDebug::Print( _L("SysAp: charger removed") ) ); + iSysApLightsController->ChargerConnectedL( EFalse ); + + if ( !iSysApUsbChargerDetector.HostOnlyUsbChargingUsed() && + iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) ) + { + if(showNote) { - case EKeyGripClose: - SetGripOpenL( EFalse ); - break; - - case EKeyGripOpen: - SetGripOpenL( ETrue ); - break; - - case EKeyFlipClose: - SetFlipOpenL( EFalse ); - break; - - case EKeyFlipOpen: - SetFlipOpenL( ETrue ); - break; - - default: - // No specific light handling for other keys. - break; + ShowUiNoteL( EUnplugChargerNote ); } } - break; - - default: - // do nothing in release builds since no harm is done - __ASSERT_DEBUG( EFalse, User::Panic( _L("CSysApAppUi::ExecCommandL: Invalid command"), KErrArgument ) ); - break; + iSysApUsbChargerDetector.Reset(); + } + else if ( aValue == EChargingStatusNotCharging ) + { + TRACES( RDebug::Print( _L("SysAp: Not charging") ) ); + } + else if ( aValue == EChargingStatusAlmostComplete ) + { + TRACES( RDebug::Print( _L("SysAp: Charging almost complete") ) ); + } + else if ( aValue == EChargingStatusChargingContinued ) + { + //in this case we simply want to scroll the battery bars and not turn light on or show ui note + // set lights controller iBatteryEmpty to EFalse + iSysApLightsController->BatteryEmptyL( EFalse ); + TRACES( RDebug::Print( _L("SysAp: charging continues") ) ); } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::ExecQueryL -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::ExecQueryL( TSysapQuery aQuery, TDes8& aReturn ) - { - ExecQueryL( aQuery, aReturn, KNullDesC8 ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ExecQueryL -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::ExecQueryL( TSysapQuery aQuery, TDes8& aReturn, const TDesC8& /*aParam*/ ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ExecQueryL: aQuery=%d"), aQuery ) ); - - switch ( aQuery ) - { - case EGetHwrmLight: // get handle to HWRM client session. Returns CHWRMLight*. - { - THwrmLightBuf retBuf( iSysApLightsController->GetHwrmLight() ); - aReturn.Copy( retBuf ); - } - break; - - case EGetKeylock: // get handle to keylock client session. Returns RAknKeylock2*. - { - TKeyLockBuf retBuf( &(KeyLock()) ); - aReturn.Copy( retBuf ); - } - break; - - default: - __ASSERT_DEBUG( EFalse, User::Panic( _L("CSysApAppUi::ExecQueryL: Invalid query"), KErrArgument ) ); - User::Leave( KErrArgument ); - break; - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowShutdownImage -// ---------------------------------------------------------------------------- -// -TInt CSysApAppUi::ShowShutdownImage( TInt aBitmapId ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowShutdownImage") ) ); - - TRAPD( err, ShowShutdownImageL( aBitmapId ) ); - - if ( err != KErrNone ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowShutdownImageL failed, err=%d"), err ) ); - } - - return err; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowShutdownImageL -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::ShowShutdownImageL( TInt aBitmapId ) - { - TRACES( RDebug::Print(_L("CSysApAppUi::ShowShutdownImageL") ) ); - - if ( !iSysApShutdownImage ) // Shutdown image may be shown without entering normal state (e.g. charging), so construct here - { - TRACES( RDebug::Print( _L("CSysApAppUi::ShowShutdownImageL: trying CSysApShutdownImage::NewL()") ) ); - iSysApShutdownImage = CSysApShutdownImage::NewL(); - } - - TRACES( RDebug::Print( _L("CSysApAppUi::ShowShutdownImageL: trying CSysApShutdownImage::ShowShutdownImageL()") ) ); - iSysApShutdownImage->ShowShutdownImageL( aBitmapId ); - } // ---------------------------------------------------------------------------- -// CSysApAppUi::IgnoreZeroNetworkBarNotifications -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::IgnoreZeroNetworkBarNotifications(TBool aIgnore) - { - iIgnoreZeroNetworkBarNotifications = aIgnore; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::BtSapEnabled() +// CSysApAppUi::UpdateBatteryBarsL( const TInt aState ) // ---------------------------------------------------------------------------- -TBool CSysApAppUi::BtSapEnabled() +void CSysApAppUi::UpdateBatteryBarsL( const TInt /* aState */) { - if ( iSysApBtSapController ) + TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) ); +// TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL aState: %d, chargerState:%d"), aState, state ) ); + HandleUsbCharger( state ); + if( state == EChargingStatusCharging || + state == EChargingStatusChargingContinued || + state == EChargingStatusAlmostComplete ) { - return iSysApBtSapController->BtSapEnabled(); + if ( !iCharging ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL: Starting Charging") ) ); + iCharging = ETrue; + } + } + else + { + if ( iCharging ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::UpdateBatteryBarsL: Stopping Charging") ) ); + iCharging = EFalse; + } } - return EFalse; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::DeactivateBT -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::DeactivateBT() - { - // Will deactivate BT when changing to normal mode - iDeactivateBt = ETrue; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetHacIndicatorL() -// ---------------------------------------------------------------------------- -void CSysApAppUi::SetHacIndicatorL() - { - - if ( !iSysApCenRepHacSettingObserver ) + if ( !iSysApPsmController ) // created here if first state change has not occurred yet { - // Do nothing if HAC setting observer has not been created yet - // This occurs in case some party is trying to set HAC indicator during - // ConstructL(), e.g. when switching from offline to online during startup - TRACES( RDebug::Print( _L("CSysApAppUi::SetHacIndicatorL: do nothing, HAC observer does not exist yet") ) ); - return; + iSysApPsmController = CSysApPsmController::NewL( *this ); } - if ( iSysApCenRepHacSettingObserver->HacMode() ) + if ( iSysApPsmController ) { - TBool accessoryConnected ( EFalse ); - - TAccMode accMode(EAccModeHandPortable); - - if ( iSysApAccessoryObserver ) - { - accMode = iSysApAccessoryObserver->GetAccessoryMode(); - - if ( accMode != EAccModeHandPortable ) - { - accessoryConnected = ETrue; - } - } - - TInt indicatorState = EAknIndicatorStateOn; - - if ( !accessoryConnected ) // When accessory is not connected, check offline and call state + if ( iSysApPsmController->FullPsmEnabled() ) { - if ( OfflineModeActive() ) // HAC indicator is not shown in offline mode - { - indicatorState = EAknIndicatorStateOff; - } - else - { - // during active call with IHF activated HAC indicator is not shown - TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ); - if ( callState < KErrNone ) - { - callState = EPSCTsyCallStateNone; - } - - if ( callState != EPSCTsyCallStateNone && IhfEnabledL() ) - { - indicatorState = EAknIndicatorStateOff; - } - } - + // activate psm indicator } else { - // If an accessory is connected, HAC indicator should not be shown - indicatorState = EAknIndicatorStateOff; - } - - SetIndicatorStateL( EAknIndicatorHAC, indicatorState ); - + // deactivate psm indicator + } } - else + + if ( iSysApBatteryInfoController ) { - // If HAC is not active, always disable indicator regardless of accessory state - SetIndicatorStateL( EAknIndicatorHAC, EAknIndicatorStateOff ); + iSysApBatteryInfoController->BatteryLevelUpdatedL(); } + + } - } // ---------------------------------------------------------------------------- -// CSysApAppUi::HandleResourceChangeL() +// CSysApAppUi::ShowChargingNoteL() // ---------------------------------------------------------------------------- -void CSysApAppUi::HandleResourceChangeL( TInt aType ) +void CSysApAppUi::ShowChargingNoteL() { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleResourceChangeL aType: %d"), aType ) ); - CAknAppUi::HandleResourceChangeL(aType); + TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL") ) ); + TBool showNote( ETrue ); - if ( aType == KEikDynamicLayoutVariantSwitch ) + TInt swState( StateOfProperty( KPSUidStartup, KPSGlobalSystemState ) ); + TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL: swState: %d"), swState ) ); + + if( UiReady() || swState == ESwStateSecurityCheck ) { -#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION - iSysApShutdownImage->SetRect( ApplicationRect() ); -#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION - - TInt mode; - User::LeaveIfError( RProperty::Get( KPSUidStartup, KPSGlobalStartupMode, mode ) ); - - if ( mode == EStartupModeAlarm ) + if ( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) == EPSCTsyCallStateRinging ) + { + showNote = EFalse; + } + TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL KCTsyCallState=%d"), StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) ) ); + if ( showNote ) // Power Mgmt UI spec defines that no Charging note is shown while the phone is ringing/alerting { - SetStatusPaneLayoutL( ESysApAlarm ); + /* + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + _LIT(KChargingNote,"txt_power_management_dblist_charging"); + HBufC* chargingNote = HbTextResolverSymbian::LoadL(KChargingNote); + CHbDeviceNotificationDialogSymbian::NotificationL(KNullDesC,*chargingNote); + */ + + _LIT(KChargingNote,"Charging"); + HBufC* aString = HBufC16::NewLC(50); + TPtrC aStringPointer = aString->Des(); + aStringPointer.Set(KChargingNote); + TRACES( RDebug::Print( _L("CSysApWsClient::RunL(): Key EEventKeyUp 01") ) ); + ShowExampleUiNoteL( aStringPointer ); + CleanupStack::PopAndDestroy(); // aString } } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetMemoryCardIndicatorL -// ---------------------------------------------------------------------------- - -void CSysApAppUi::SetMemoryCardIndicatorL() - { - if ( iSysApFeatureManager->Supported( KSysApFeatureIdMemoryCardIcon ) ) - { -#ifndef RD_MULTIPLE_DRIVE - TSysApMemoryCardStatus memoryCardStatus = iSysApMMCObserver->MemoryCardStatus(); - - TRACES( RDebug::Print( _L("CSysApAppUi::SetMemoryCardIndicatorL: memoryCardStatus=%d"), memoryCardStatus ) ); - - if ( memoryCardStatus == ESysApMemoryCardInserted || memoryCardStatus == ESysApMemoryCardLocked ) -#else // RD_MULTIPLE_DRIVE - TInt insertedCount( CSysApDriveList::NonUsbDriveCount( iInsertedMemoryCards ) ); - - TRACES( RDebug::Print( _L("CSysApAppUi::SetMemoryCardIndicatorL: insertedCount=%d"), insertedCount ) ); - - if ( insertedCount > 0 ) -#endif // RD_MULTIPLE_DRIVE - { - SetIndicatorStateL( EAknIndicatorMemoryCard, EAknIndicatorStateOn ); - } - else - { - SetIndicatorStateL( EAknIndicatorMemoryCard, EAknIndicatorStateOff ); - } - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SysApFeatureManager -// ---------------------------------------------------------------------------- - -CSysApFeatureManager& CSysApAppUi::SysApFeatureManager() - { - __ASSERT_DEBUG( iSysApFeatureManager, User::Panic( _L("iSysApFeatureManager == NULL"), KErrBadHandle ) ); - - return *iSysApFeatureManager; - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::SetUsbAttachStatus -// ---------------------------------------------------------------------------- -#ifndef RD_MULTIPLE_DRIVE -void CSysApAppUi::SetUsbAttachStatus( const TBool aUsbAttached ) - { - // Prevent double beep when USB file transfer gets activated but - // allow MMC inserted beep when: - // a) USB file transfer is active - // b) MMC is not inserted when USB cable is attached - iHideNextBeep = ( iMMCInserted && aUsbAttached ); - } -#else // RD_MULTIPLE_DRIVE -void CSysApAppUi::SetUsbAttachStatus( const TBool aUsbAttached ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::SetUsbAttachStatus: aUsbAttached: %d" ), - aUsbAttached ) ); - - if ( aUsbAttached ) - { - // For ignoring extra beeps caused by USB file transfer - iSysApDriveList->ResetDrivesInsertBeepIgnored(); - iSysApDriveList->MarkDrivesInsertBeepIgnored( iInsertedMemoryCards ); - } - } -#endif // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::IhfEnabledL -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::IhfEnabledL() - { - TRACES( RDebug::Print( _L("CSysApAppUi::IhfEnabledL(): iSysApAudioRoutingObserver=0x%x"), iSysApAudioRoutingObserver ) ); - - if ( !iSysApAudioRoutingObserver ) // create observer if needed - { - iSysApAudioRoutingObserver = CSysApAudioRoutingObserver::NewL( *this ); - } - - return iSysApAudioRoutingObserver->IhfEnabled(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::IsDeviceModeKey -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::IsDeviceModeKey( const TKeyEvent& aKeyEvent ) const - { - return CSysApDefaultKeyHandler::IsDeviceModeKey( aKeyEvent ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ResourcesFreed -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::ResourcesFreed() const - { - return iResourcesFreed; - } - -/* ----------------------------------------------------------------------------- -CSysApAppUi::IsEncryptionOperationOngoingL() -Introduced the code as a part of Sub : 405-3362 - Power Management SUB for ES -recapture functionalities in platform which support multidrive as well. -------------------------------------------------------------------------------- -*/ -TBool CSysApAppUi::IsEncryptionOperationOngoingL() const - { - TBool deFeatureSupported(EFalse); - FeatureManager::InitializeLibL(); - deFeatureSupported = FeatureManager::FeatureSupported( KFeatureIdFfDeviceEncryptionFeature); - FeatureManager::UnInitializeLib(); - - if(deFeatureSupported) - { - /** - * Store the last memory status changed - * 0: Idle. It can be Encrypted or Decrypted - * 1: Encrypting - * 2: Decrypting - **/ - - RProperty deProperty; - User::LeaveIfError(deProperty.Attach(KDevEncProtectedUid, KDevEncOperationKey,EOwnerThread)); - TInt deValue = 0; - if((deProperty.Get(deValue)== KErrNone)&&( deValue == EOpEncrypting || deValue == EOpDecrypting)) - { - deProperty.Close(); - return ETrue; - } - else - { - deProperty.Close(); - return EFalse; - } - } - else - { - return EFalse; - } - } -// ---------------------------------------------------------------------------- -// CSysApAppUi::EtelConnector -// ---------------------------------------------------------------------------- - -CSysApEtelConnector* CSysApAppUi::EtelConnector() const - { - return iSysApEtelConnector; - } - -#ifndef RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::EjectUsed -// ---------------------------------------------------------------------------- - -void CSysApAppUi::EjectUsed( TInt /*aDrive*/ ) - { - } - -#else // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::ShowEjectWaitNoteL -// ---------------------------------------------------------------------------- - -void CSysApAppUi::ShowEjectWaitNoteL( TInt aDriveToEject ) - { - if ( iSysApWaitNote ) - { - return; - } - HBufC* text = iSysApDriveList->GetFormattedDriveNameLC( - aDriveToEject, - 0, // Not used - R_QTN_EJECTING_MEMORY_NAME_WAIT ); - iSysApWaitNote = CSysApWaitNote::NewL( - iSysApFeatureManager->CoverDisplaySupported() ); - iSysApWaitNote->ShowNoteL( EClosingApplicationsNote, text ); - CleanupStack::PopAndDestroy( text ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::IsEjectQueryVisible -// ---------------------------------------------------------------------------- - -TBool CSysApAppUi::IsEjectQueryVisible() - { - if ( !iSysApConfirmationQuery ) - { - return EFalse; - } - TInt queryId( iSysApConfirmationQuery->CurrentQuery() ); - return ( queryId == ESysApEjectMmcQuery || queryId == ESysApRemoveMmcNote ); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UpdateInsertedMemoryCardsL -// ---------------------------------------------------------------------------- - -void CSysApAppUi::UpdateInsertedMemoryCardsL() - { - // Update inserted memory cards - iSysApDriveList->GetMemoryCardsL( - iInsertedMemoryCards, CSysApDriveList::EIncludeInserted ); - - // Update memory card indicator status - SetMemoryCardIndicatorL(); - - // Handle unlock - RunUnlockNotifierL(); - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::EjectUsed -// ---------------------------------------------------------------------------- - -void CSysApAppUi::EjectUsed( TInt aDrive ) - { - // Check drive inserted before starting eject confirm query - TInt insertedIndex( CSysApDriveList::Find( iInsertedMemoryCards, aDrive ) ); - - TRACES( RDebug::Print( - _L( "CSysApAppUi::EjectUsed: drive: %d, index: %d" ), - aDrive, insertedIndex ) ); - - if ( insertedIndex == KErrNotFound ) - { - return; - } - - iMMCEjectUsed = ETrue; - iDriveToEject = aDrive; - iSysApDriveList->ResetDrivesToEject(); - TRAPD( err, EjectMMCL() ); - if ( err != KErrNone ) - { - TRACES( RDebug::Print( - _L( "CSysApAppUi::EjectUsed: err: %d" ), err ) ); - iMMCEjectUsed = EFalse; - } - } - -#endif // RD_MULTIPLE_DRIVE - -// ---------------------------------------------------------------------------- -// CSysApAppUi::EjectMMCCanceled -// ---------------------------------------------------------------------------- - -void CSysApAppUi::EjectMMCCanceled() - { - // Called from eject confirm query, reset eject status -#ifdef RD_MULTIPLE_DRIVE - iMMCEjectUsed = EFalse; -#endif // RD_MULTIPLE_DRIVE - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::UsbChargerDetector -// ---------------------------------------------------------------------------- -// -TSysApUsbChargerDetector& CSysApAppUi::UsbChargerDetector() - { - return iSysApUsbChargerDetector; - } // ---------------------------------------------------------------------------- // CSysApAppUi::HandleUsbCharger @@ -6527,36 +2227,252 @@ } // ---------------------------------------------------------------------------- -// CSysApAppUi::SetEnvelopeIndicatorL +// CSysApAppUi::HandleCurrentCallStateChangeL() // ---------------------------------------------------------------------------- -// -void CSysApAppUi::SetEnvelopeIndicatorL() + +void CSysApAppUi::HandleCurrentCallStateChangeL( TInt aCurrentCallState ) { - TInt phoneStoreStatus( StateOfProperty( KUidPSSMSStackCategory, KUidPSSMSStackDiskSpaceMonitorKey ) ); - TInt inboxStatus( StateOfProperty( KUidSystemCategory, KUidInboxStatusValue ) ); - TBool simStoreFull( iSysApEtelConnector && iSysApEtelConnector->IsSimSmsStoreFull() ); + TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: KUidCurrentCall: %d" ), aCurrentCallState ) ); + + switch ( aCurrentCallState ) + { + case EPSCTsyCallStateRinging: + { + iSysApLightsController->CallComingInL( ETrue ); + // Disable keylock when a call is coming in + if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCradle || iKeyLockOnBeforeAlarm ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateRinging: disable keylock") ) ); + iKeyLockOnBeforeCall = ETrue; + + if ( iKeyLockEnabled || iDeviceLockEnabled ) + { + if ( !iSysApFeatureManager->TouchUnlockStrokeSupported() ) + { + iKeyguardController->DisableKeyguard(EFalse); + } + } + } + break; + } + + case EPSCTsyCallStateDialling: + { + // Disable keypad lock during an emergency call + // no need to disable the key lock when a call is made using the wireless car-kit + // but if the call is an emergency one then we will disable the keypad lock + if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCradle ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateDialling: disable keylock") ) ); + iKeyLockOnBeforeCall = ETrue; + + if ( IsEmergencyCall() && (iKeyLockEnabled || iDeviceLockEnabled )) + { + iKeyguardController->DisableKeyguard(EFalse); + } + } + + // Enable signal & network indicators when an emergency call is made in Offline Mode + if( iSysApOfflineModeController->OfflineModeActive() ) + { + // Signal indicators not updated with VoIP call + if ( StateOfProperty(KPSUidCtsyCallInformation, KCTsyCallType) != EPSCTsyCallTypeVoIP) + { + iEmergencyCallActive = ETrue; + // not supporting this + // UpdateSignalBarsL(); + // SetSignalIndicatorL(); + } + } + break; + } + + case EPSCTsyCallStateConnected: + { + if (StateOfProperty(KPSUidCtsyCallInformation, KCTsyCallType) == EPSCTsyCallTypeCSVoice) + { + // Check if GPRS suspended note is required + iCallActivated = ETrue; + // not supporting this + // HandleGprsNotesL(); + } + if ( iDeviceLockEnabled ) + { + // Enable keylock via autolock emulation if device lock enabled. + // Otherwise e.g. messages can be read using softkeys during ongoing call. + iKeyguardController->EnableKeyguard(EFalse); + } + break; + } + + case EPSCTsyCallStateNone: + { + // Reset timers in ScreenSaver and Autolock + User::ResetInactivityTime(); - TRACES( RDebug::Print( - _L("CSysApAppUi::SetEnvelopeIndicatorL() phoneStoreStatus %d, simStoreFull %d, inboxStatus %d"), - phoneStoreStatus, simStoreFull, inboxStatus ) ); + if ( iEmergencyCallActive ) + { + iEmergencyCallActive = EFalse; + // not supporting this + // UpdateSignalBarsL( 0 ); + // SetSignalIndicatorL(); + } + if ( iKeyLockOnBeforeCall ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateNone: enable keylock") ) ); + iKeyLockOnBeforeCall = EFalse; + if ( !iDeviceLockEnabled ) + { + if ( !iKeyLockOnBeforeCradle && !iKeyLockOnBeforeAlarm && + !iSysApFeatureManager->TouchUnlockStrokeSupported() ) + { + if ( iSysApCenRepController->GetInt( KCRUidCommonTelephonySettings, KSettingsSummaryAfterCall ) == 1 ) + { + // Let's not hide "Summary After Call" dialog + iKeyguardController->EnableKeyguard(EFalse); + } + else + { + iKeyguardController->EnableKeyguard(ETrue); + } + } + } + else + { + iKeyguardController->EnableKeyguard(EFalse); + } + } + if ( iShowkeypadActivatedNoteAfterSoftReject ) + { + ShowUiNoteL( EKeypadActiveNote ); + iShowkeypadActivatedNoteAfterSoftReject = EFalse; + } + iCallActivated = EFalse; + break; + } + + default: + break; + } - if ( phoneStoreStatus == ESmsDiskSpaceFull || simStoreFull ) + if ( aCurrentCallState != EPSCTsyCallStateRinging ) { - // Blink the Envelope indicator - SetIndicatorStateL( EAknIndicatorEnvelope, EAknIndicatorStateAnimate ); + iSysApLightsController->CallComingInL( EFalse ); } - else if ( inboxStatus == ESADocumentsInInbox ) + + SetIhfIndicatorL(); + SetHacIndicatorL(); + } + + + +/** + * To check the for an emergency call. + * + * @return ETrue if there is an emergency call active otherwise, EFalse. + */ +TBool CSysApAppUi::IsEmergencyCall() { - // Show the Envelope indicator. - SetIndicatorStateL( EAknIndicatorEnvelope, EAknIndicatorStateOn ); + TBool retVal( EFalse ); + TInt err( KErrNone ); + TInt state( 0 ); + + err = RProperty::Get(KPSUidCtsyEmergencyCallInfo, KCTSYEmergencyCallInfo, state ); + if ( err == KErrNone && state ) + { + retVal = ETrue; + } + return retVal; + } + + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::IsStateNormal() +// +// ---------------------------------------------------------------------------- +TBool CSysApAppUi::IsStateNormal() const + { + TInt state; + TInt errorCode = + RProperty::Get( KPSUidStartup, KPSGlobalSystemState, state ); + if ( errorCode == KErrNone ) + { + return state == ESwStateNormalRfOn || + state == ESwStateNormalRfOff || + state == ESwStateNormalBTSap; } else { - // Hide the Envelope indicator. - SetIndicatorStateL( EAknIndicatorEnvelope, EAknIndicatorStateOff ); + TRACES( RDebug::Print( _L( "CSysApAppUi::IsStateNormal: Failed to read global system state, error code %d." ), errorCode ) ); + return EFalse; } } - + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleAccessoryProfileInStartupL() +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleAccessoryProfileInStartupL() + { + TRACES( RDebug::Print( _L( "CSysApAppUi::HandleAccessoryProfileInStartupL" ) ) ); + + if ( !iSysApOfflineModeController->OfflineModeActive() ) + { + iIgnoreAccessorySpecificProfileChanges = EFalse; + TBool accessoryConnectedInShutdown( EFalse ); + TInt accessoryTemp( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected ) ); + if ( accessoryTemp == 1 ) + { + accessoryConnectedInShutdown = ETrue; + } + + TBool accessoryConnectedNow ( EFalse ); + + TAccMode accessoryState(EAccModeHandPortable); + if ( iSysApAccessoryObserver ) + { + accessoryState = iSysApAccessoryObserver->GetAccessoryMode(); + } + + if ( accessoryState != EAccModeHandPortable ) + { + accessoryConnectedNow = ETrue; + } + TRACES( RDebug::Print( _L( "CSysApAppUi::HandleAccessoryProfileInStartupL: accessoryConnectedInShutdown: %d, accessoryConnectedNow: %d" ), + accessoryConnectedInShutdown, accessoryConnectedNow ) ); + + if ( accessoryConnectedInShutdown && !accessoryConnectedNow ) + { + HandleAccessoryDisconnectedL(); + } + else if ( !accessoryConnectedInShutdown && accessoryConnectedNow ) + { + HandleAccessoryConnectedL( accessoryState ); + } + else if ( !accessoryConnectedNow ) + { + // not supporting this + // TInt activeProfile ( ActiveProfileId() ); + // SysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApActiveProfileBeforeAccessoryConnected, activeProfile ); + } + } + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::CenRepController() +// ---------------------------------------------------------------------------- + +CSysApCenRepController& CSysApAppUi::CenRepController() + { + __ASSERT_ALWAYS( iSysApCenRepController, User::Panic( _L("CSysApAppUi::CenRepController"), KErrBadHandle ) ); + + return *iSysApCenRepController; + } + + // ---------------------------------------------------------------------------- // CSysApAppUi::LogsObserverL // ---------------------------------------------------------------------------- @@ -6573,192 +2489,249 @@ return *iSysApCenRepLogsObserver; } - + + // ---------------------------------------------------------------------------- -// CSysApAppUi::NotifyPowerSaveModeL +// CSysApAppUi::HandleWlanIndicator() // ---------------------------------------------------------------------------- -// -void CSysApAppUi::NotifyPowerSaveModeL( TSysApPsmStatus aStatus ) +void CSysApAppUi::HandleWlanIndicatorL( TInt aValue ) { - TRACES( RDebug::Print( _L("CSysApAppUi::NotifyPowerSaveModeL aStatus: %d"), aStatus ) ); - - // cancel any active power saving query because user has changed the state manually - CancelQuery( ESysApBattChargingPowerSavingQuery ); - CancelQuery( ESysApBattLowPowerSavingQuery ); - - switch ( aStatus ) + if ( aValue == EPSWlanIndicatorAvailable ) + { + // do nothing + } + else if ( aValue == EPSWlanIndicatorActive ) + { + // do nothing + } + else if ( aValue == EPSWlanIndicatorActiveSecure ) + { + // do nothing + } + else // No indication required { - case MSysApPsmControllerNotifyCallback::EPsmActivationComplete: - UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - ShowUiNoteL( EPowerSaveModeActivated ); - break; - - case MSysApPsmControllerNotifyCallback::EPsmDeactivationComplete: - UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - ShowUiNoteL( EPowerSaveModeDeactivated ); - break; - - case MSysApPsmControllerNotifyCallback::EPsmActivationFailed: - ShowUiNoteL( ECannotActivatePowerSaveMode ); - break; - - case MSysApPsmControllerNotifyCallback::EPsmDeactivationFailed: - ShowUiNoteL( ECannotDeactivatePowerSaveMode ); - break; - - default: - break; + // do nothing + } + } + +void CSysApAppUi::ShowNotificationDialog(const TDesC& noteText)const +{ + //Todo:4.Notification--Just Popup message + //Todo: #include + CHbDeviceNotificationDialogSymbian *notificationDialog = CHbDeviceNotificationDialogSymbian::NewL(); + CleanupStack::PushL(notificationDialog); + notificationDialog->SetTextL(noteText);//noteText with Qm file input + notificationDialog->SetTimeout(100); + notificationDialog->ShowL(); + CleanupStack::PopAndDestroy(notificationDialog); +} + +void CSysApAppUi::SetKeyLockEnabledL() + { + iKeyLockEnabled = ETrue; + iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive, 1 ); + // not supporting indicator +// SetIndicatorStateL( EAknIndicatorKeyguard, EAknIndicatorStateOn ); + iSysApLightsController->KeylockStateChangedL( ETrue ); + } + +void CSysApAppUi::SetKeyLockDisabledL() + { + iKeyLockEnabled = EFalse; + iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApKeyguardActive, 0 ); + // SetIndicatorStateL( EAknIndicatorKeyguard, EAknIndicatorStateOff ); + if (! iDeviceLockEnabled ) + { + iSysApLightsController->KeylockStateChangedL( EFalse ); + if ( iSysApFeatureManager->MmcHotSwapSupported() ) + { + if ( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) != EPSCTsyCallStateRinging && StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) != EPSCTsyCallStateAlerting ) + { + // RunUnlockNotifierL(); + // need to handle MMC unlock query in next sub + } + } } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleBatteryStatusL -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::HandleBatteryStatusL( const TInt aValue ) +void CSysApAppUi::SetLightsOnUnlockNoteL() + { + iSysApLightsController->SetLightsOnUnlockNoteL(); + } + +void CSysApAppUi::SetLightsOnEcsQueryL() { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleBatteryStatusL aValue: %d"), aValue ) ); - - if ( aValue == EBatteryStatusEmpty ) - { - //Display Recharge Battery note - ShowUiNoteL( ERechargeBatteryNote ); - BatteryEmptyL(); - } - else if ( aValue == EBatteryStatusLow ) - { - if ( iSysApPsmController && UiReady() ) - { - iSysApPsmController->BatteryLow( ETrue ); - - if ( iSysApPsmController->ShowActivateQuery()) - { - // show activation query, replaces the first battery low query - ShowQueryL( ESysApBattLowPowerSavingQuery ); - } - else // default low warning note must be shown - { - // activate partial power save mode on first low warning - iSysApPsmController->DoEnablePartialPsm( ETrue ); // activated on first warning note - //Display Battery Low note. - ShowUiNoteL( EBatteryLowNote ); - } - } - else - { - //Display Battery Low note. - ShowUiNoteL( EBatteryLowNote ); - } - } - - if ( iSysApBatteryInfoController ) - { - iSysApBatteryInfoController->BatteryStatusUpdated( aValue ); - } - + iSysApLightsController->SetLightsOnEcsQueryL(); + } + +void CSysApAppUi::SetLightsOnSecurityQueryL() + { + iSysApLightsController->SetLightsOnSecurityQueryL(); + } + +TBool CSysApAppUi::CheckLongPowerKeyPressed() + { + return iCheckLongPowerKeyEvent; } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleChargingStatusL + // ---------------------------------------------------------------------------- -// -void CSysApAppUi::HandleChargingStatusL( const TInt aValue ) +// CSysApAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType ) +// ---------------------------------------------------------------------------- + +TKeyResponse CSysApAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType ) { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleChargingStatusL aValue: %d"), aValue ) ); - - TBool showNote( ETrue ); - - UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) ); - - if ( iSysApPsmController && UiReady() ) + if ( ! iShutdownStarted ) { - if ( iCharging ) // iCharging updated in UpdateBatteryBarsL + TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL: aKeyEvent.iCode:%d, aKeyEvent.iScanCode:%d, aType:%d, iIgnoreNextPowerKeyUpEvent:%d, iPowerKeyPopupMenuActive:%d, iLastPowerKeyWasShort:%d, iPowerKeyPopupMenuDismissed:%d"), + aKeyEvent.iCode, aKeyEvent.iScanCode, aType, iIgnoreNextPowerKeyUpEvent, iPowerKeyPopupMenuActive, iLastPowerKeyWasShort, iPowerKeyPopupMenuDismissed ) ); + +#ifdef _DEBUG + // camery latency measurement environment instrumentation, don't remove + if ( aType == EEventKey && aKeyEvent.iCode == EKeyCamera ) { - // cancel activation query if charger is connected while query is on display - CancelQuery( ESysApBattLowPowerSavingQuery ); + TRACES( RDebug::Print( _L("e_KEY_EVENT_SENDING 0") ) ); } - - if ( iCharging && !iSysApPsmController->ChargerConnected() ) // first time after charger connection +#endif // _DEBUG + + TKeyResponse response(EKeyWasNotConsumed); + if (response) + { + //Do nothing:: To supress warning + } + if (iSysApKeyManagement && aKeyEvent.iCode != EKeyPowerOff && aKeyEvent.iCode != 'E') + { + response = iSysApKeyManagement->HandleKeyEventL(aKeyEvent, aType ); + } + + if( aType == EEventKey ) { - iSysApPsmController->ConnectCharger( ETrue ); - - if ( iSysApPsmController->ShowDeactivateQuery() ) - { - ShowQueryL( ESysApBattChargingPowerSavingQuery ); - // Query is on the display. Don't show the note. - showNote = EFalse; - } - else + switch ( aKeyEvent.iCode ) { - iSysApPsmController->DoEnablePartialPsm( EFalse ); - } +#ifdef _DEBUG + case 'E': //For testing + Exit(); + break; +#endif + case EKeyPowerOff: + //Short power key press + iKeyBoardRepeatCount++; + if( aKeyEvent.iRepeats == 0 ) + { + TRACES( RDebug::Print(_L("CSysApAppUi::HandleKeyEventL, Short powerkey") ) ); + iLastPowerKeyWasShort = ETrue; + TRACES( RDebug::Print( _L("CSysApAppUi::Key was consumed by pressing short power") ) ); + //Powermenu + if (iPowerMenuDialog != NULL) + { + //PowerMenu already exist + delete iPowerMenuDialog; + iPowerMenuDialog = NULL; + } + + iPowerMenuDialog = CHbDevicePowerMenuSymbian::NewL(*this); + iPowerMenuDialog->ShowL(); + iIgnoreNextPowerKeyRepeats = EFalse; + } + //Long power key press + else if( aKeyEvent.iRepeats > 0 && iKeyBoardRepeatCount >= iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApPowerkeyRepeatcount )) + { + iKeyBoardRepeatCount = -1; + TRACES( RDebug::Print(_L("CSysApAppUi::HandleKeyEventL, Long powerkey") ) ); + iLastPowerKeyWasShort = EFalse; + HandleLongPowerKeyPressedL(); + } + break; + + default: + { + TKeyResponse response = EKeyWasNotConsumed; + if (iSysApKeyManagement) + { + response = iSysApKeyManagement->HandleKeyEventL(aKeyEvent, aType ); + } + + if ( response == EKeyWasNotConsumed ) // none of the plugins consumed the key, offer it to default handling + { + iSysApDefaultKeyHandler->HandleKeyEventL( aKeyEvent, aType ); + } + } + break; + } } - else if ( aValue == EChargingStatusNotConnected ) + else if( aType == EEventKeyUp ) { - iSysApPsmController->ConnectCharger( EFalse ); - - // cancel deactivation query if charger is disconnected while query is on display - CancelQuery( ESysApBattChargingPowerSavingQuery ); - } + if( aKeyEvent.iScanCode == EStdKeyDevice2 ) + { + if ( iIgnoreNextPowerKeyUpEvent ) + { + if ( !iPowerKeyPopupMenuDismissed ) // If the popup menu has been dismissed, do nothing + { + iPowerKeyPopupMenuActive = ETrue; + iIgnoreNextPowerKeyUpEvent = EFalse; + } + } + else if( iLastPowerKeyWasShort ) + { + if ( iPowerKeyPopupMenuActive ) + { + } + } + + } + } + + TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL:ended, aKeyEvent.iCode:%d, aKeyEvent.iScanCode:%d, aType:%d, iIgnoreNextPowerKeyUpEvent:%d, iPowerKeyPopupMenuActive:%d, iLastPowerKeyWasShort:%d, iPowerKeyPopupMenuDismissed:%d"), + aKeyEvent.iCode, aKeyEvent.iScanCode, aType, iIgnoreNextPowerKeyUpEvent, iPowerKeyPopupMenuActive, iLastPowerKeyWasShort, iPowerKeyPopupMenuDismissed ) ); } - if( showNote ) + else // shutdown started { - HandleChargerNotesL( aValue ); + TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL: aKeyEvent.iCode:%d, aKeyEvent.iScanCode:%d, aType:%d"), + aKeyEvent.iCode, aKeyEvent.iScanCode, aType ) ); + + // When shutdown has been started, only device mode key events are passed to plug-in framework + // This for enabling plug-in activities during shutdown animation + if ( IsDeviceModeKey( aKeyEvent ) ) // Other key events are not passed, because they must cancel the shutdown animation as stated in UI spefication + { + if ( aType == EEventKey && iSysApKeyManagement ) + { + iSysApKeyManagement->HandleKeyEventL( aKeyEvent, aType ); + } + } + TRACES( RDebug::Print( _L("CSysApAppUi::HandleKeyEventL: ended") ) ); + } + return EKeyWasConsumed; + } + + +// ---------------------------------------------------------------------------- +// CSysApAppUi::HandleCommandL( TInt aCommand) +// ---------------------------------------------------------------------------- + +void CSysApAppUi::HandleCommandL( TInt aCommand ) + { + TRACES( RDebug::Print( _L("CSysApAppUi::HandleCommandL aCommend: %d"), aCommand ) ); + switch ( aCommand ) + { + case EEikCmdExit: // EAknCmdExit + Exit(); + break; + default: + break; } } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleActivatePsmQueryResponse -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::HandleActivatePsmQueryResponse( TBool aEnable ) +TBool CSysApAppUi::ReleasePowerMenuCustomDialogMemory() { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleActivatePsmQueryResponse aEnable: %d"), - aEnable ) ); - - __ASSERT_DEBUG( iSysApPsmController, User::Invariant() ); - - if ( aEnable ) + if (iPowerMenuDialog!=NULL) { - iSysApPsmController->DoEnableFullPsm( ETrue ); + //PowerMenu already exist + delete iPowerMenuDialog; + iPowerMenuDialog = NULL; + return ETrue; } - else - { - iSysApPsmController->DoEnablePartialPsm( ETrue ); - } + return EFalse; } -// ---------------------------------------------------------------------------- -// CSysApAppUi::HandleDeactivatePsmQueryResponse -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::HandleDeactivatePsmQueryResponse( TBool aDisable ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::HandleDeactivatePsmQueryResponse aDisable: %d"), - aDisable ) ); - __ASSERT_DEBUG( iSysApPsmController, User::Invariant() ); - - if ( aDisable ) - { - iSysApPsmController->DoEnableFullPsm( EFalse ); - } - } - -// ---------------------------------------------------------------------------- -// CSysApAppUi::CancelQuery -// ---------------------------------------------------------------------------- -// -void CSysApAppUi::CancelQuery( TSysApConfirmationQueryIds aQueryId ) - { - TRACES( RDebug::Print( _L("CSysApAppUi::CancelQuery aQueryId: %d"), aQueryId ) ); - - if ( iSysApConfirmationQuery ) - { - if ( aQueryId == iSysApConfirmationQuery->CurrentQuery() || aQueryId == ESysApNoQuery ) - { - iSysApConfirmationQuery->Cancel(); - } - } - } -// End of File +//end of file