/*

* Copyright (c) 2005-2010 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;

const TInt KHWSwitchGroup( 29 );

const TInt KHWSwitchGrip( 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

    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") ) );

    /*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 );

    //initially set the value as 0 assuming mmc is not inserted

    RProperty::Set( KPSUidUikon, KUikMMCInserted, 0 );

    TDriveInfo driveInfo;

    TInt driveNumber; 

    TInt err;    

    RFs& fileServer = iEikonEnv->FsSession();  

    for ( driveNumber = EDriveD; driveNumber < EDriveZ; driveNumber++ )

         {

	  err = fileServer.Drive(driveInfo,driveNumber);

          if(driveNumber==EDriveF && err == KErrNone && driveInfo.iType == EMediaHardDisk &&  driveInfo.iDriveAtt & KDriveAttRemovable)     

        	{     

          TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: err = %d, driveInfo.iType = %d, driveInfo.iDriveAtt %d, KDriveAttRemovable = %d "),err,driveInfo.iType,driveInfo.iDriveAtt,KDriveAttRemovable) );     

        	RProperty::Set( KPSUidUikon, KUikMMCInserted, 1 );

               break;  // Memory card drive found...     

      		}

         } 

    RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsHideAlarm, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );

    RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsDisableKeyguard, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );

    RProperty::Define( KPSUidCoreApplicationUIs, KCoreAppUIsSoftReject, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );

    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 );

    TInt status(0);

    err = UserSvr::HalFunction( KHWSwitchGroup, KHWSwitchGrip, &status, 0 );

    if( err == KErrNone )

	    {

	    if( status == 0 )

		    {

	        RProperty::Set( KPSUidHWRM, KHWRMGripStatus, EPSHWRMGripOpen );

		    }

	    else

		    {

		    RProperty::Set( KPSUidHWRM, KHWRMGripStatus, EPSHWRMGripClosed );

		    }

	    }

     else

	    {

	    TRACES ( RDebug::Print( _L("CSysApAppUi::ConstructL: error in getting slide status: err = %d"), err ) );

	    }

#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 );

    DeactivatePSMifBatteryNotLowL ();

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: END") ) );

    }

// ----------------------------------------------------------------------------

// CSysApAppUi::DeactivatePSMifBatteryNotLow()

// ----------------------------------------------------------------------------

 void CSysApAppUi::DeactivatePSMifBatteryNotLowL ()

    {

    TRACES( RDebug::Print( _L("CSysApAppUi::DeactivatePSMifBatteryNotLow: Start") ) );

    if ( iSysApFeatureManager->PowerSaveSupported()) //&& iSysApFeatureManager->Supported( KSysApFeatureIdBatteryInfoPopup ))

        {

        // Create batteruInfoController to get current battery status;

	if(iSysApBatteryInfoController == NULL)

	    {

	    iSysApBatteryInfoController = CSysApBatteryInfoController::NewL( 

                                                        iSysApCenRepController->GetInt( 

                                                                KCRUidCoreApplicationUIsConf,

                                                                KCoreAppUIsBatteryInformationLowThreshold ) );

	    }

        //Querry the battery level 

        TBool status = iSysApBatteryInfoController->IsBatteryInfoAboveThreshold();

        TRACES( RDebug::Print( _L("CCSysApAppUi::DeactivatePSMifBatteryNotLow  IsBatteryInfoAboveThreshold=%d"), status ) );

        // Querry to deactivate PSM if PSM is activated and battery status is above threshold

        if (status)

            {

			if(iSysApPsmController == NULL)

				{

				iSysApPsmController = CSysApPsmController::NewL( *this );

				}

            if ( iSysApPsmController->ShowDeactivateQuery())

                ShowQueryL( ESysApBattChargingPowerSavingQuery );

            else