--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/coreapplicationuis/SysAp/Src/SysApAppUi.cpp Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,6736 @@
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: CSysApAppUi implementation.
+*
+*/
+
+
+// INCLUDES
+
+#include <avkon.hrh>
+#include <avkon.rsg>
+#include <eikon.hrh>
+#include <apgwgnam.h>
+#include <eiksrv.h>
+#include <eikdll.h>
+#include <AknSmallIndicator.h>
+#include <AknBatteryNotify.h>
+#include <AknSignalNotify.h>
+#include <AknGlobalNote.h>
+#include <AknGlobalListQuery.h>
+#include <aknsoundsystem.h>
+#include <apgcli.h>
+
+#include <hwrmpowerstatesdkpskeys.h>
+#include <hwrmdomainpskeys.h>
+
+#include <PSVariables.h>
+#include "CoreApplicationUIsPrivatePSKeys.h"
+#include <ctsydomainpskeys.h>
+#include <startupdomainpskeys.h>
+#include <startupdomaincrkeys.h>
+
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+ #include <ASShdAlarm.h>
+#else
+ #include <asshddefs.h>
+ #include <ASShdAlarmCal.h>
+ #include <asshdalarm.h>
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+
+#include <MProfileEngine.h>
+#include <MProfileName.h>
+#include <MProfilesNamesArray.h>
+#include <MProfile.h>
+#include <StringLoader.h>
+#include <secuisystemlock.h>
+#include <secui.h>
+#include <settingsinternalcrkeys.h>
+
+#include <AknNotifierController.h>
+#include <eikappui.h>
+#include <es_enum.h>
+#include <data_caging_path_literals.hrh>
+#include <eikon.hrh>
+
+#include "SysApSimChanged.h"
+
+#include <SysAp.rsg>
+#include "SysApLightsController.h"
+
+#include "SysApPubSubObserver.h"
+#include "SysApProfileObserver.h"
+
+#include "sysapcenreplightsettingsobserver.h"
+#include "SysApCenRepLogsObserver.h"
+#include "SysApCenRepBTObserver.h"
+#include "SysApCenRepHacSettingObserver.h"
+#include "SysApCenRepController.h"
+#include "CoreApplicationUIsPrivateCRKeys.h"
+#include "CoreApplicationUIsPrivatePSKeys.h"
+#include <UikonInternalPSKeys.h>
+
+#include "SysApStartupController.h"
+#include "SysApConnectionMonitorObserver.h"
+#include "SysApPowerKeyMenuObserver.h"
+#include "SysApSsSettingsObserver.h"
+#include "SysApAppUi.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 <sysap.mbg>
+
+#include "SysApShutdownAnimation.h"
+
+#include <hwrmfmtx.h>
+#include <hwrmfmtxdomainpskeys.h>
+#include <hwrmfmtxdomaincrkeys.h>
+#include "sysapcenrepfmtxobserver.h"
+
+#include "SysApKeySndHandler.h"
+
+#include <ir_sock.h> // KIrdaPropertyCategory // KIrdaStatus
+
+#include <NetworkHandlingDomainPSKeys.h>
+
+// POC launching
+#include <AiwServiceHandler.h>
+#include <AiwPoCParameters.h>
+
+#include <sacls.h> // KUidPhonePwr
+
+#include <wlaninternalpskeys.h> // WLan indicator
+
+#include <ecom/ecom.h>
+#include "sysapkeymanagement.h"
+
+#include "SysApMediatorObserver.h"
+
+#include <SecondaryDisplay/SecondaryDisplaySysApAPI.h>
+#include "aknSDData.h"
+
+#include <AknTaskList.h>
+#include <layoutmetadata.cdl.h>
+
+#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 "sysappsmcontroller.h"
+#include "sysapbatteryinfocontroller.h"
+
+#include <keylockpolicyapi.h>
+
+#include <UsbWatcherInternalPSKeys.h> // USB transfer modes
+#include <usbpersonalityids.h>
+#include <smsuaddr.h>
+#include <featmgr.h>
+#include <DevEncProtectedPSKey.h>
+
+// CONSTANTS
+const TInt KPowerKeyMenuSelectionCancelled( -1 );
+const TInt KPowerKeyMenuSelectionSwitchOff( 0 );
+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);
+
+// ============================ MEMBER FUNCTIONS ==============================
+
+// ----------------------------------------------------------------------------
+// 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::ConstructL()
+// ----------------------------------------------------------------------------
+
+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: BaseConstructL() OK") ) );
+
+ iFlagForRmvMmcFrmShortPwrKey = EFalse;
+
+ /*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<CAknAppUi*>(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: 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() );
+
+ 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 );
+ RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsPoCMissedIndicator, ECoreAppUIsPocMissedIndicatorUninitialized );
+
+ // initial value won't be set to KCoreAppUIsUSBFileTransfer, because UsbMscPersonality-plugin may also define it if USB cable is connected during boot
+ // remove this definition after all clients have taken the USB personality ids in use
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsUSBFileTransfer, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+
+ 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 );
+
+ TDriveInfo driveInfo;
+ TInt driveNumber;
+ TInt err;
+ RFs& fileServer = iEikonEnv->FsSession();
+ for ( driveNumber = EDriveD; driveNumber < EDriveZ; driveNumber++ )
+ {
+ err = fileServer.Drive(driveInfo,driveNumber);
+ if(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 );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsUipInd, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsMessageToneQuit, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsNspsRawKeyEvent, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsLightsRawKeyEvent, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsMmcRemovedWithoutEject, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KLightsAlarmLightActive, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KLightsVTForcedLightsOn, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KLightsATCForcedLightsOn, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KLightsControl, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsTarmIndicator, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsMtvRecStatus, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsMtvDvbhStatus, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+ RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsNewEmailStatus, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );
+
+ // Initialize P&S keys "owned" by SysAp
+ RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsHideAlarm, ECoreAppUIsHideAlarmUninitialized );
+
+ TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApStartupController::NewL()") ) );
+ iSysApStartupController = CSysApStartupController::NewL( *this, iSysApFeatureManager->OfflineModeSupported() );
+
+ 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
+
+ //Instantiate the KEF plugin manager
+ //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 );
+
+ // 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)
+ TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApShutdownImage::NewL()") ) );
+ iSysApShutdownImage = CSysApShutdownImage::NewL();
+
+ // 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
+
+ // 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 );
+
+ TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: END") ) );
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::~CSysApAppUi()
+// ----------------------------------------------------------------------------
+
+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") ) );
+ }
+
+
+// ----------------------------------------------------------------------------
+// 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;
+ }
+ }
+ }
+
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType )
+// ----------------------------------------------------------------------------
+
+TKeyResponse CSysApAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType )
+ {
+ 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;
+ }
+
+// ----------------------------------------------------------------------------
+// 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::HandleApplicationSpecificEventL(TInt aType,const TWsEvent& aEvent)
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleApplicationSpecificEventL(TInt aType,const TWsEvent& aEvent)
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleApplicationSpecificEventL: aType:%d"), aType ) );
+
+ CAknAppUi::HandleApplicationSpecificEventL(aType, aEvent);
+
+ if ( ResourcesFreed() )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleApplicationSpecificEventL: discarded, shutting down") ) );
+ return;
+ }
+
+ switch( aType )
+ {
+ 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();
+ break;
+
+ default:
+ break;
+ }
+ }
+
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::InitializeStatusPaneAreaL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::InitializeStatusPaneAreaL()
+ {
+ 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
+ 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();
+ }
+
+ 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 )
+ {
+ 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 );
+ }
+ else
+ {
+ TRACES( RDebug::Print(_L("CSysApAppUi::InitializeStatusPaneAreaL called the SetIndicatorStateL with EActiveNoWakeupAlarmsSet ")));
+ SetIndicatorStateL( EAknIndicatorAlarmClock, EAknIndicatorStateOff );
+ }
+
+ state = StateOfProperty( KIrdaPropertyCategory, KIrdaStatus );
+ if( state == TIrdaStatusCodes::EIrLoaded || state == TIrdaStatusCodes::EIrDisconnected || state == TIrdaStatusCodes::EIrBlocked )
+ {
+ SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateAnimate );
+ }
+ else if( state == TIrdaStatusCodes::EIrConnected )
+ {
+ SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateOn );
+ }
+ 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 );
+ }
+
+ // 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 );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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
+ {
+ StartShutDownTimerOnAlarmAndChargingStates();
+ }
+ else
+ //to charging state
+ {
+ SetStarterState( RStarterSession::ECharging );
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleLongPowerKeyPressedL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleLongPowerKeyPressedL()
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleLongPowerKeyPressedL()") ) );
+
+ TInt swState;
+ RProperty::Get( KPSUidStartup, KPSGlobalSystemState, swState );
+
+ iSysApLightsController->PowerKeyPressedL();
+
+ if( swState == ESwStateStartingCriticalApps ||
+ swState == ESwStateSelfTestOK ||
+ swState == ESwStateSecurityCheck ||
+ swState == ESwStateCriticalPhaseOK ||
+ swState == ESwStateEmergencyCallsOnly ||
+ swState == ESwStateNormalRfOn ||
+ swState == ESwStateNormalRfOff ||
+ swState == ESwStateNormalBTSap ||
+ swState == ESwStateFatalStartupError )
+ {
+ if( !iDeviceLockEnabled )
+ {
+ if( iPowerKeyPopupMenuActive )
+ {
+ if ( iGlobalListQuery )
+ {
+ iGlobalListQuery->SelectItem();
+ }
+ }
+ else if( !iIgnoreNextPowerKeyRepeats )
+ {
+ if( !iKeyLockEnabled && !IsEncryptionOperationOngoingL() )
+ {
+ DoShutdownL( EFalse, KDummyReason );
+ }
+ }
+ iIgnoreNextPowerKeyRepeats = ETrue;
+ }
+ }
+ else if( swState == ESwStateAlarm )
+ {
+ //Just comment here to highlight that this is not possible since
+ //from alarm state already a short press always shuts the device down.
+ }
+ else if( swState == ESwStateCharging )
+ //Startup to Normal state
+ {
+ if( !iIgnoreNextPowerKeyRepeats )
+ {
+ iIgnoreNextPowerKeyRepeats = ETrue;
+
+ SetStarterState( RStarterSession::ENormal );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::ShowUiNoteL( const TSysApNoteIds aNote ) const
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::ShowUiNoteL aNote: %d"), aNote ) );
+
+ TInt tone( EAvkonSIDNoSound );
+ TAknGlobalNoteType noteType( EAknGlobalBatteryLowNote );
+ CAknGlobalNote* note = CAknGlobalNote::NewLC();
+ TInt secondaryDisplayId(SecondaryDisplay::ECmdNoNote);
+
+ switch ( aNote )
+ {
+ 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;
+
+ }
+
+ 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<TReal>( frequencykHz ) / KCoefficientKhzToMhz; // kHz to Mhz
+ TBuf<KFrequencyMaxLength> 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<CAknAppUi*>(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( tone );
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // note
+ }
+
+// ----------------------------------------------------------------------------
+// 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<CAknAppUi*>(iEikonEnv->EikAppUi())->KeySounds()->PlaySound( EAvkonSIDChargingBatteryTone );
+ }
+ else
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::ShowChargingNoteL - No note shown") ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleChargerNotesL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::HandleChargerNotesL( const TInt aValue )
+ {
+ 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 )
+ {
+ iSysApLightsController->ChargingCompleteL();
+
+ TSysApNoteIds note( EBatteryFullNote );
+
+ if ( !iSysApUsbChargerDetector.HostOnlyUsbChargingUsed() &&
+ iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) )
+ {
+ note = EBatteryFullUnplugChargerNote;
+ }
+ iSysApUsbChargerDetector.Reset();
+ if(showNote)
+ {
+ 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 );
+ }
+ }
+ 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::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<KMaxProfileNameLength> 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()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::ShowQueryL( const TSysApConfirmationQueryIds aQueryId, const TDesC& aValue )
+ {
+ CancelGlobalListQuery();
+
+ 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 ( !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.
+ }
+ 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;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::SetSignalIndicatorGsmL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::SetSignalIndicatorGsmL()
+ {
+ 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 );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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 );
+ }
+
+ TInt signalWcdmaIndicatorState;
+ TInt signalHsdpaIndicatorState;
+
+ switch ( wcdmaStatus )
+ {
+ 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;
+ }
+
+ TBool showHsdpaAvailable = EFalse;
+
+ if ( iSysApFeatureManager->Supported( KSysApFeatureIdUseHsdpaAvailableIcon ) )
+ {
+ // HSDPA Resource Availability information is a configurable feature.
+ showHsdpaAvailable = iSysApEtelConnector->HsdpaAvailable();
+ }
+
+ 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 );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleGprsNotesL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleGprsNotesL()
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleGprsNotesL" ) ) );
+ if ( iSysApFeatureManager->Supported( KSysApFeatureIdGPRSNotes ) )
+ {
+ // 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 )
+ {
+ if ( iGprsActivated && iGprsSuspended && iCallActivated && !iGprsSuspendedNoteShown )
+ {
+ StartGprsSuspendedTimer();
+ }
+ else if ( iGprsSuspendedNoteShown && !iGprsSuspended )
+ {
+ ShowUiNoteL( EGprsResumedNote );
+ iGprsSuspendedNoteShown = EFalse;
+ iGprsSuspended = EFalse;
+ iCallActivated = 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()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::GoOnlineL( TBool aDoProfileChange )
+ {
+ if ( iSysApFeatureManager->OfflineModeSupported() )
+ {
+ 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();
+
+ if ( aDoProfileChange )
+ {
+ TRAPD( err, ActivateProfileL( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileBeforeOfflineMode ) ) );
+ if ( err == KErrNotFound )
+ {
+ // 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);
+ }
+ }
+
+ iSysApOfflineModeController->SwitchFromOfflineToOnlineModeL();
+ TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: iActivateBt = %d" ), iActivateBt ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::GoOfflineL()
+// ----------------------------------------------------------------------------
+
+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<TFmTxState>(StateOfProperty( KPSUidHWRMFmTx, KHWRMFmTxStatus ));
+ switch ( 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();
+ }
+
+// ----------------------------------------------------------------------------
+// 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 );
+ }
+ else
+ {
+ UpdateSignalBarsL();
+ }
+
+ // Update network mode indicator
+ SetSignalIndicatorL();
+
+ // Update HAC indicator
+ SetHacIndicatorL();
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::OfflineModeActive()
+// ----------------------------------------------------------------------------
+TBool CSysApAppUi::OfflineModeActive()
+ {
+ return iSysApOfflineModeController->OfflineModeActive();
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::DoNotActivateBt()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::DoNotActivateBt()
+ {
+ 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
+// ----------------------------------------------------------------------------
+
+TBool CSysApAppUi::DeviceLockState() const
+ {
+ return iDeviceLockEnabled;
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::ChangeFmTxStateL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::ChangeFmTxStateL( TBool aEnable )
+ {
+ // disable fm transmission
+ CHWRMFmTx* fmtx = CHWRMFmTx::NewLC();
+ if ( aEnable )
+ {
+ fmtx->EnableL();
+ }
+ else
+ {
+ fmtx->DisableL();
+ }
+ CleanupStack::PopAndDestroy( fmtx );
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::SetIhfIndicatorL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::SetIhfIndicatorL()
+ {
+ TBool accessoryConnected ( EFalse );
+
+ TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) );
+
+ TAccMode accMode(EAccModeHandPortable);
+
+ if ( iSysApAccessoryObserver )
+ {
+ accMode = iSysApAccessoryObserver->GetAccessoryMode();
+
+ if ( accMode != EAccModeHandPortable )
+ {
+ accessoryConnected = ETrue;
+ }
+ }
+
+ 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 );
+ }
+ }
+ 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 ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::ShowGprsSuspendedNoteAfterCallBack( TAny* aObject )
+// ----------------------------------------------------------------------------
+
+TInt CSysApAppUi::ShowGprsSuspendedNoteAfterCallBack( TAny* aObject )
+ {
+ 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;
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleAccessoryConnectedL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleAccessoryConnectedL( TAccMode aAccessoryState )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryConnectedL( aAccessoryState: %d ) "), aAccessoryState ) );
+
+ 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 )
+ {
+ 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 );
+ }
+
+ if ( ( ! iIgnoreAccessorySpecificProfileChanges ) && ( ! iSysApOfflineModeController->OfflineModeActive() ) )
+ {
+ TInt profileId( 0 );
+ TInt currentProfile( 0 );
+ currentProfile = ActiveProfileId();
+
+ if ( iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected ) < 1 )
+ // accessory not connected already
+ {
+ iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApAccessoryConnected, 1 );
+ iSysApCenRepController->SetInt( KCRUidCoreApplicationUIsSysAp, KSysApActiveProfileBeforeAccessoryConnected, currentProfile );
+ }
+
+ 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 );
+ }
+ }
+ }
+ SetIhfIndicatorL();
+ SetHacIndicatorL();
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleAccessoryDisconnectedL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleAccessoryDisconnectedL()
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleAccessoryDisconnectedL()" ) ) );
+
+
+ TAccMode accessoryState(EAccModeHandPortable);
+ if ( iSysApAccessoryObserver )
+ {
+ accessoryState = iSysApAccessoryObserver->GetAccessoryMode();
+ }
+
+ 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() );
+
+ 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 )
+ {
+ iKeyLockOnBeforeCradle = EFalse;
+ if ( !iKeyLockOnBeforeCall && !iKeyLockOnBeforeAlarm )
+ {
+ if ( !iDeviceLockEnabled )
+ {
+ KeyLock().EnableKeyLock();
+ }
+ else
+ {
+ KeyLock().EnableAutoLockEmulation();
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::CloseUIAppsInHotSwapL()
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::CloseUIAppsInHotSwapL") ) );
+
+ CArrayFixFlat<TInt>* wgIds=new(ELeave) CArrayFixFlat<TInt>(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();
+ }
+ }
+
+#endif // RD_MULTIPLE_DRIVE
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::TimerExpiredL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::TimerExpiredL()
+ {
+#ifndef RD_MULTIPLE_DRIVE
+ CloseUIAppsInHotSwapL();
+#endif // RD_MULTIPLE_DRIVE
+ }
+
+#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()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::InitCloseSimApplicationsL()
+ {
+ iApplicationScanningRoundNumberInBtSap = 0;
+ iTimeToKillInBtSap = EFalse;
+ CloseSimApplicationsL();
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::CloseSimApplicationsL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::CloseSimApplicationsL()
+ {
+ iApplicationScanningRoundNumberInBtSap++;
+ TRACES( RDebug::Print( _L("CSysApAppUi::CloseSimApplicationsL: scanning round = %d"),
+ iApplicationScanningRoundNumberInBtSap ) );
+
+ if ( iApplicationScanningRoundNumberInBtSap == KMaxExitTimeInBtSap )
+ {
+ iTimeToKillInBtSap = ETrue;
+ }
+
+ const TInt KNumberOfSimDependantApps( 7 );
+ TUid simDependantAppUid[ KNumberOfSimDependantApps ];
+ simDependantAppUid[ 0 ] = KSysApGSUid;
+ simDependantAppUid[ 1 ] = KSysApSATUid;
+ simDependantAppUid[ 2 ] = KSysApMailboxUid;
+ simDependantAppUid[ 3 ] = KSysApSpeedDialingUid;
+ simDependantAppUid[ 4 ] = KSysApSimDirectoryUid;
+ simDependantAppUid[ 5 ] = KSysApMCEUid;
+ simDependantAppUid[ 6 ] = KSysApCellBroadcastMessagesUid;
+
+ TBool appsExiting( EFalse );
+ TApaTaskList apaTaskList( CCoeEnv::Static()->WsSession() );
+
+ for ( TInt i = 0; i < KNumberOfSimDependantApps; i++ )
+ {
+ TApaTask apaTask = apaTaskList.FindApp( simDependantAppUid[ i ] );
+ if ( apaTask.Exists() )
+ {
+ appsExiting = ETrue;
+ if ( iApplicationScanningRoundNumberInBtSap == 1 )
+ {
+ apaTask.EndTask(); // applications are kindly requested to close themselves on the first round
+ }
+ else if ( iTimeToKillInBtSap )
+ {
+ apaTask.KillTask(); // used after timeout on the last round
+ }
+ }
+ }
+
+ if ( !appsExiting || iTimeToKillInBtSap )
+ {
+ iSysApBtSapController->SimApplicationsClosed();
+ }
+ else
+ {
+ if ( !iSapTimer )
+ {
+ iSapTimer = CPeriodic::NewL( EPriorityNormal );
+ }
+ iSapTimer->Cancel();
+ iSapTimer->Start( KDelayBeforeNextScanningRound,
+ KDelayBeforeNextScanningRound,
+ TCallBack( DoCloseSimApplicationsAfterCallBack, this ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::DoCloseSimApplicationsAfterCallBack
+// ----------------------------------------------------------------------------
+TInt CSysApAppUi::DoCloseSimApplicationsAfterCallBack( TAny* aObject )
+ {
+ CSysApAppUi* appUi = STATIC_CAST( CSysApAppUi*, aObject );
+
+ if ( appUi->iSapTimer )
+ {
+ appUi->iSapTimer->Cancel();
+ }
+
+ TRAP_IGNORE( appUi->CloseSimApplicationsL() );
+
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::AlertUiAlertingL( const TBool aAlerting )
+// ----------------------------------------------------------------------------
+void CSysApAppUi::AlertUiAlertingL( const TBool aAlerting )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::AlertUiAlerting aAlerting:%d"), aAlerting ) );
+
+ if ( aAlerting )
+ {
+ TInt swState;
+ RProperty::Get( KPSUidStartup, KPSGlobalSystemState, swState );
+
+ if( swState == ESwStateCharging )
+ {
+ SetStarterState( RStarterSession::EAlarm );
+ }
+ }
+
+ iSysApLightsController->AlarmOccuredL( aAlerting );
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::AlertUiKeyLockOff( const TBool aKeyLockOff )
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::AlertUiKeyLockOff( const TBool aKeyLockOff )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::AlertUiKeyLockOff aKeyLockOff:%d, devicelock:%d"),
+ aKeyLockOff, iDeviceLockEnabled ) );
+
+ if( aKeyLockOff )
+ {
+ // Notification to release keypad might come several times if e.g. calls are received
+ if ( !iKeyLockOnBeforeAlarm )
+ {
+ if ( iKeyLockEnabled || iKeyLockOnBeforeCradle || iKeyLockOnBeforeCall )
+ {
+ iKeyLockOnBeforeAlarm = ETrue;
+ }
+ }
+ KeyLock().DisableWithoutNote();
+ }
+ else
+ {
+ if (iDeviceLockEnabled)
+ {
+ // Re-enable keylock in devicelock case only if phone call is not ongoing or is
+ // connected. Otherwise e.g. messages can be read using softkeys during ongoing call.
+ TInt callState( StateOfProperty( KPSUidCtsyCallInformation, KCTsyCallState ) );
+ if ( callState == EPSCTsyCallStateNone || callState == EPSCTsyCallStateConnected )
+ {
+ KeyLock().EnableAutoLockEmulation();
+ }
+ }
+ else if ( iKeyLockOnBeforeAlarm && !iKeyLockOnBeforeCradle && !iKeyLockOnBeforeCall )
+ {
+ KeyLock().EnableKeyLock();
+ }
+ iKeyLockOnBeforeAlarm = EFalse;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleLightsRequireL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleLightsRequireL() const
+ {
+ iSysApLightsController->HandleLightsRequireL();
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleRawKeyEventLightsRequireL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleRawKeyEventLightsRequireL() const
+ {
+ iSysApLightsController->HandleRawKeyEventLightsRequireL();
+ }
+
+// ----------------------------------------------------------------------------
+// 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::SwitchLightsOnSoftRejectL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::SwitchLightsOnSoftRejectL()
+ {
+ 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<TInt> 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<KMaxProfileNameLength> 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();
+ iFlagForRmvMmcFrmShortPwrKey = ETrue;
+ 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 )
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::SetDeviceLockEnabledL( const TBool aLockEnabled )
+ {
+ TRACES( RDebug::Print(_L("CSysApAppUi::SetDeviceLockEnabledL aLockEnabled:%d" ), aLockEnabled ) );
+ TBool currentState( iDeviceLockEnabled );
+
+ iDeviceLockEnabled = aLockEnabled;
+
+ if ( currentState != iDeviceLockEnabled ) // filter out unnecessary light status modifications
+ {
+ iSysApLightsController->DeviceLockStateChangedL( iDeviceLockEnabled );
+ }
+
+ if( iDeviceLockEnabled )
+ {
+ if( iKeyLockEnabled )
+ {
+ KeyLock().DisableWithoutNote();
+ }
+ }
+ else
+ {
+ // let's not activate keylock in case device lock was disabled during call or in cradle
+ iKeyLockOnBeforeCall = EFalse;
+ iKeyLockOnBeforeCradle = EFalse;
+
+ // 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<RStarterSession::TResetReason>( 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
+ }
+ }
+
+ 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<CAknAppUi*>(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()
+// ----------------------------------------------------------------------------
+
+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
+ {
+ static_cast<CAknAppUi*>(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 );
+ }
+ 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()
+ {
+ 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;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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 keylock during an emergency call
+ if ( iKeyLockEnabled || iDeviceLockEnabled || iKeyLockOnBeforeCradle )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleCurrentCallStateChangeL: EPSCTsyCallStateDialling: disable keylock") ) );
+ iKeyLockOnBeforeCall = ETrue;
+
+ if ( iKeyLockEnabled || iDeviceLockEnabled )
+ {
+ KeyLock().DisableWithoutNote();
+ }
+ }
+
+ // enable signal & network indicators when an emergency call is made in Offline Mode
+ if( iSysApOfflineModeController->OfflineModeActive() )
+ {
+ if ( StateOfProperty(KPSUidCtsyCallInformation, KCTsyCallType) != EPSCTsyCallTypeVoIP) // signal indicators not updated with VoIP call
+ {
+ 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()
+// ----------------------------------------------------------------------------
+
+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()
+ {
+ 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;
+ }
+
+// ----------------------------------------------------------------------------
+// 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() )
+ {
+ TSysApMemoryCardStatus memoryCardStatus;
+ if ( aMemoryCardStatus == ESysApMemoryCardStatusNotKnown )
+ {
+ memoryCardStatus = iSysApMMCObserver->MemoryCardStatus();
+ }
+ else
+ {
+ memoryCardStatus = aMemoryCardStatus;
+ }
+
+ TRACES( RDebug::Print( _L("CSysApAppUi::RunUnlockNotifierL: memoryCardStatus=%d"), memoryCardStatus ) );
+
+ switch ( memoryCardStatus )
+ {
+ 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("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 )
+ {
+ if(!iFlagForRmvMmcFrmShortPwrKey)
+ {
+ RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 );
+ }
+ iFlagForRmvMmcFrmShortPwrKey = EFalse;
+ }
+ 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<CAknAppUi*>(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()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::BatteryEmptyL()
+ {
+ iSysApLightsController->BatteryEmptyL( ETrue );
+ // Do not reactivate keyguard in the next startup
+ 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()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::SimulateFlipKeyEventL( TBool aFlipOpen )
+ {
+ 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 );
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::SetFlipOpenL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::SetFlipOpenL( TBool aFlipOpen )
+ {
+ iSysApLightsController->SetFlipOpenL( aFlipOpen );
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::SetGripOpenL()
+// ----------------------------------------------------------------------------
+void CSysApAppUi::SetGripOpenL( TBool aGripOpen )
+ {
+ iSysApLightsController->SetGripOpenL( aGripOpen );
+ }
+
+// ----------------------------------------------------------------------------
+// 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::GetTelServerL()
+// ----------------------------------------------------------------------------
+
+RTelServer* CSysApAppUi::GetTelServer()
+ {
+ if ( iSysApEtelConnector )
+ {
+ return iSysApEtelConnector->GetTelServer();
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::ExecCommandL( TSysapCommand aCommand )
+ {
+ ExecCommandL( aCommand, KNullDesC8 );
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::ExecCommandL
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::ExecCommandL( TSysapCommand aCommand, const TDesC8& aParam )
+ {
+ TRACES( RDebug::Print(_L("CSysApAppUi::ExecCommandL: aCommand=%d"), aCommand ) );
+
+ switch ( aCommand )
+ {
+ 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
+ {
+ TUpdateLightsBuf lightBuf;
+ lightBuf.Copy( aParam );
+
+ switch ( lightBuf() )
+ {
+ 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;
+ }
+ }
+ 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::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()
+// ----------------------------------------------------------------------------
+
+TBool CSysApAppUi::BtSapEnabled()
+ {
+ if ( iSysApBtSapController )
+ {
+ return iSysApBtSapController->BtSapEnabled();
+ }
+
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::DeactivateBT
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::DeactivateBT()
+ {
+ // Will deactivate BT when changing to normal mode
+ iDeactivateBt = ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// 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;
+ }
+ }
+
+ TInt indicatorState = EAknIndicatorStateOn;
+
+ if ( !accessoryConnected ) // When accessory is not connected, check offline and call state
+ {
+ 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;
+ }
+ }
+
+ }
+ else
+ {
+ // If an accessory is connected, HAC indicator should not be shown
+ indicatorState = EAknIndicatorStateOff;
+ }
+
+ SetIndicatorStateL( EAknIndicatorHAC, indicatorState );
+
+ }
+ else
+ {
+ // If HAC is not active, always disable indicator regardless of accessory state
+ SetIndicatorStateL( EAknIndicatorHAC, EAknIndicatorStateOff );
+ }
+
+
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleResourceChangeL()
+// ----------------------------------------------------------------------------
+
+void CSysApAppUi::HandleResourceChangeL( TInt aType )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleResourceChangeL aType: %d"), aType ) );
+ CAknAppUi::HandleResourceChangeL(aType);
+
+ if ( aType == KEikDynamicLayoutVariantSwitch )
+ {
+#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 )
+ {
+ SetStatusPaneLayoutL( ESysApAlarm );
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::HandleUsbCharger( const TInt aValue )
+ {
+ if ( aValue == EChargingStatusCharging ||
+ aValue == EChargingStatusChargingContinued ||
+ aValue == EChargingStatusAlmostComplete )
+ {
+ iSysApUsbChargerDetector.SetChargingUsed( ETrue );
+ if ( !iSysApUsbIndicatorController &&
+ iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) &&
+ iSysApFeatureManager->Supported( KSysApFeatureIdUsbChargingWithoutReminderNotes ) )
+ {
+ // Start observing USB state for the reminder note
+ TRAPD ( usbErr, iSysApUsbIndicatorController = CreateSysApUsbIndicatorL( *this ) );
+ if ( usbErr )
+ {
+ TRACES( RDebug::Print(
+ _L("CSysApAppUi::HandleUsbCharger: error in constructing USB ind. controller %d" ),
+ usbErr ) );
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::SetEnvelopeIndicatorL
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::SetEnvelopeIndicatorL()
+ {
+ TInt phoneStoreStatus( StateOfProperty( KUidPSSMSStackCategory, KUidPSSMSStackDiskSpaceMonitorKey ) );
+ TInt inboxStatus( StateOfProperty( KUidSystemCategory, KUidInboxStatusValue ) );
+ TBool simStoreFull( iSysApEtelConnector && iSysApEtelConnector->IsSimSmsStoreFull() );
+
+ TRACES( RDebug::Print(
+ _L("CSysApAppUi::SetEnvelopeIndicatorL() phoneStoreStatus %d, simStoreFull %d, inboxStatus %d"),
+ phoneStoreStatus, simStoreFull, inboxStatus ) );
+
+ if ( phoneStoreStatus == ESmsDiskSpaceFull || simStoreFull )
+ {
+ // Blink the Envelope indicator
+ SetIndicatorStateL( EAknIndicatorEnvelope, EAknIndicatorStateAnimate );
+ }
+ else if ( inboxStatus == ESADocumentsInInbox )
+ {
+ // Show the Envelope indicator.
+ SetIndicatorStateL( EAknIndicatorEnvelope, EAknIndicatorStateOn );
+ }
+ else
+ {
+ // Hide the Envelope indicator.
+ SetIndicatorStateL( EAknIndicatorEnvelope, EAknIndicatorStateOff );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::LogsObserverL
+// ----------------------------------------------------------------------------
+//
+CSysApCenRepLogsObserver& CSysApAppUi::LogsObserverL()
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::LogsObserverL()") ) );
+
+ // Create Logs observer when it is needed for the first time
+ if ( !iSysApCenRepLogsObserver )
+ {
+ iSysApCenRepLogsObserver = CSysApCenRepLogsObserver::NewL( *this );
+ }
+
+ return *iSysApCenRepLogsObserver;
+ }
+
+// ----------------------------------------------------------------------------
+// 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 );
+
+ 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::HandleBatteryStatusL
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::HandleBatteryStatusL( const TInt aValue )
+ {
+ 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 );
+ }
+
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleChargingStatusL
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::HandleChargingStatusL( const TInt aValue )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleChargingStatusL aValue: %d"), aValue ) );
+
+ TBool showNote( ETrue );
+
+ UpdateBatteryBarsL( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) );
+
+ if ( iSysApPsmController && UiReady() )
+ {
+ if ( iCharging ) // iCharging updated in UpdateBatteryBarsL
+ {
+ // cancel activation query if charger is connected while query is on display
+ CancelQuery( ESysApBattLowPowerSavingQuery );
+ }
+
+ 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 );
+
+ // cancel deactivation query if charger is disconnected while query is on display
+ CancelQuery( ESysApBattChargingPowerSavingQuery );
+ }
+ }
+ if( showNote )
+ {
+ HandleChargerNotesL( aValue );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CSysApAppUi::HandleActivatePsmQueryResponse
+// ----------------------------------------------------------------------------
+//
+void CSysApAppUi::HandleActivatePsmQueryResponse( TBool aEnable )
+ {
+ TRACES( RDebug::Print( _L("CSysApAppUi::HandleActivatePsmQueryResponse aEnable: %d"),
+ aEnable ) );
+
+ __ASSERT_DEBUG( iSysApPsmController, User::Invariant() );
+
+ if ( aEnable )
+ {
+ iSysApPsmController->DoEnableFullPsm( ETrue );
+ }
+ else
+ {
+ iSysApPsmController->DoEnablePartialPsm( ETrue );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// 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