/*

* 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 <startupdomainpskeys.h>

#include "sysapappui.h"

#include "coreapplicationuisprivatepskeys.h"

#include <HbDeviceMessageBoxSymbian.h>

//#include <hbdevicepowermenusymbian.h>

#include <sacls.h>

#include <featmgr.h>

#include <DevEncProtectedPSKey.h>

#include <ctsydomainpskeys.h>

#include <secuisystemlock.h>

#include <apgtask.h>

#include <hwrmpowerstatesdkpskeys.h>

#include <wlaninternalpskeys.h> 

#include <HbDeviceNotificationDialogSymbian.h>

#include <hbsymbianvariant.h>

#include <hbtextresolversymbian.h>

#include <UikonInternalPSKeys.h>

//#include "SysApWsClient.h"

#include "SysApFeatureManager.h"

#include "SysApNspsHandler.h"

#include "SysApPubSubObserver.h"

#include "sysapdefaultkeyhandler.h"

#include "SysApStartupController.h"

#include "MSysApOfflineModeController.h"

#include "SysApCenRepController.h"

#include "sysapcenreplightsettingsobserver.h"

#include "SysApCenRepLogsObserver.h"

#include "SysApCenRepBTObserver.h"

#include "SysApCenRepHacSettingObserver.h"

#include "sysapaudioroutingobserver.h"

#include "sysapbatteryinfocontroller.h"

#include "SysApSimChanged.h"

#include "MSysApBtSapController.h"

#include "MSysApBtController.h"

#include "MSysApUsbIndicator.h"

#include "sysapkeymanagement.h"

#include "SysApShutdownImage.h"

#include "SysApKeySndHandler.h"

#include "SysApShutdownAnimation.h"

#include "SysApEtelConnector.h"

#ifdef RD_MULTIPLE_DRIVE

#include "sysapdrivelist.h"

#include "sysapdriveunlockhandler.h"

#include "sysapdriveejecthandler.h"

#include "hbdeviceinputdialogsymbian.h"

#endif // RD_MULTIPLE_DRIVE

#include <settingsinternalcrkeys.h>

#include <keyguardaccessapi.h>

#include <eikdef.h>

#include <eikenv.h>

#include <UsbWatcherInternalPSKeys.h> // USB transfer modes

#include <usbpersonalityids.h>

#include "sysap.rsg"

#include <hbindicatorsymbian.h>

class CHbSymbianVariant;

const TInt KModifierMask( 0 );

_LIT_SECURITY_POLICY_PASS(KAlwaysPassPolicy);

_LIT_SECURITY_POLICY_C1(KWriteDeviceDataPolicy, ECapabilityWriteDeviceData);

const TInt KDelayBeforeNextScanningRound( 1000000 );

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

_LIT(KAccesoryPlugin,"com.nokia.accessory.indicatorplugin/1.0");

_LIT(KAccMode, "AccMode");

_LIT(KAccPhyConType, "AccType");

_LIT(KPsmPlugin,"com.nokia.hb.powersavemodeplugin/1.0");

_LIT(KPsm,"PSM");

_LIT(KCharging,"Charging");

_LIT(KPsmlocalisationfile, "powermanagement_");

_LIT(KtsfilePath, "z:/resource/qt/translations/");

_LIT(KlowbatteryIcon,"qtg_small_bt_low_battery.svg");

_LIT(KbatteryFullIcon,"qtg_status_battery.svg");

// ============================ MEMBER FUNCTIONS ==============================

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

// CSysApAppUi::CSysApAppUi()

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

CSysApAppUi::CSysApAppUi()

    :iSysApShutdownImage(NULL),

     iPowerMenuDialog(NULL),

     iDeviceLockEnabled(EFalse),

     iKeyLockEnabled(EFalse),

     iPowerKeyPopupMenuActive(EFalse),

     iResourcesFreed (EFalse),

     iShutdownStarted (EFalse),

     iSysApAudioRoutingObserver (NULL),

     iSysApBatteryInfoController (NULL),

     iSysApPsmController(NULL),

     iSapTimer (NULL),

     iSysApCenRepLogsObserver (NULL),

     iSysApUsbIndicatorController(NULL),

     iKeyguardController (NULL),

     iKeyLockOnBeforeCall (EFalse),

     iCheckLongPowerKeyEvent (EFalse),

     iMMCEjectUsed( EFalse ),               

     iMemCardPwdDialog(NULL)

	{

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

    BaseConstructL();

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: BaseConstructL() OK") ) );

    iEikonEnv->SetSystem( ETrue );

    iEikonEnv->WsSession().ComputeMode( RWsSession::EPriorityControlDisabled );

    RThread().SetProcessPriority( EPriorityForeground );

    TInt mode;

    User::LeaveIfError( RProperty::Get( KPSUidStartup, KPSGlobalStartupMode, mode ) );

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: KPSGlobalStartupMode = %d"), mode ) );

    //SysAp needs to capture PowerKey events because it handles all functionality related to that

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CEikApplication::RootWin()") ) );

    RWindowGroup groupWin = iCoeEnv->RootWin();

    User::LeaveIfError ( iCapturedEKeyPowerOff = groupWin.CaptureKey( EKeyPowerOff, KModifierMask, KModifierMask ) );

    User::LeaveIfError ( iCapturedEKeyPowerOffUpAndDowns = groupWin.CaptureKeyUpAndDowns( EStdKeyDevice2, KModifierMask, KModifierMask ) );

    TRACES ( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApDefaultKeyHandler::NewL()") ) );

    iSysApDefaultKeyHandler = CSysApDefaultKeyHandler::NewL(*this);

    // Define P&S keys "owned" by SysAp

    RProperty::Define( KPSUidUikon, KUikMMCInserted, RProperty::EInt, KAlwaysPassPolicy, KWriteDeviceDataPolicy );

    //initially assuming that the memory card is not inserted

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

    TDriveInfo driveInfo;

    TInt driveNumber; 

    TInt err;    

    RFs& fileServer = iEikonEnv->FsSession();  

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

         {

      err = fileServer.Drive(driveInfo,driveNumber);

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

            {     

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

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

                break;  // Memory card drive found...     

            }

         }

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApFeatureManager::NewL()") ) );

    iSysApFeatureManager = CSysApFeatureManager::NewL();

    // Setup USB charging detector

     iSysApUsbChargerDetector.EnableUsbCharging(

         iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) &&

         iSysApFeatureManager->Supported( KSysApFeatureIdUsbChargingWithoutReminderNotes ) );

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

    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 CSysApAccessoryObserver::NewL()") ) );

    iSysApAccessoryObserver = CSysApAccessoryObserver::NewL( *this );

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepController::NewL()") ) );

    iSysApCenRepController = CSysApCenRepController::NewL();

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepLightSettingsObserver::NewL") ) );

    iSysApCenRepLightSettingsObserver = CSysApCenRepLightSettingsObserver::NewL( *this );

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApCenRepBtObserver::NewL") ) );

    iSysApCenRepBtObserver = CSysApCenRepBtObserver::NewL( *this );

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApStartupController::NewL()") ) );

    iSysApStartupController = CSysApStartupController::NewL( *this, iSysApFeatureManager->OfflineModeSupported() );

    iActiveProfileBeforeOfflineMode = iSysApCenRepController->GetInt( KCRUidCoreApplicationUIsSysAp, KSysApProfileBeforeOfflineMode );    

    iSysApFeatureManager->FeatureVariationCheckDone();        

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApLightsController::NewL()") ) );

    iSysApLightsController = CSysApLightsController::NewL( *this,

                                                           iSysApCenRepLightSettingsObserver->GetLightsTimeout(),

                                                           iSysApFeatureManager->CoverDisplaySupported() );

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying CreateSysApOfflineModeControllerL()") ) );

    iSysApOfflineModeController = CreateSysApOfflineModeControllerL( *this );

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : trying DoInitialSwStateCheckL()") ) );

    iSysApStartupController->DoInitialSwStateCheckL();

    TRACES( RDebug::Print( _L("CCSysApAppUi::ConstructL  trying CSysApCenRepHacSettingObserver::NewL") ) );

    iSysApCenRepHacSettingObserver = CSysApCenRepHacSettingObserver::NewL( *this ); 

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

        }

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApEtelConnector::NewL()") ) );

    iSysApEtelConnector = CSysApEtelConnector::NewL( *this );

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

    iKeyguardController = CKeyguardAccessApi::NewL();

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApShutdownImage::NewL()") ) );

    iSysApShutdownImage = CSysApShutdownImage::NewL();//NULL; //

    // Initialize nsps handler. Needed for proper lights control during PIN query.

    TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CSysApNspsHandler::NewL") ) );

    iSysApNspsHandler = CSysApNspsHandler::NewL( iEikonEnv->WsSession(), iSysApShutdownImage->ShutdownCoeControlWindow() );

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

    RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsPowerMenuCustomDialogStatus, ECoreAppUIsPowerMenuCustomDialogUninitialized );

	TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL: trying CHbIndicatorSymbian::NewL()") ) );

    iHbIndicatorSymbian = CHbIndicatorSymbian::NewL();

	  TBool result = HbTextResolverSymbian::Init(KPsmlocalisationfile, KtsfilePath);

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

    }

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

// CSysApAppUi::FreeResources()

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

void CSysApAppUi::FreeResources()

    {

    TRACES( RDebug::Print( _L("CSysApAppUi::FreeResources") ) );

    delete iSysApBatteryInfoController;

    delete iSysApPsmController;

    delete iVariantAccState; 

    delete iSysApAudioRoutingObserver;

    if (iMemCardPwdDialog!=NULL)

        {

        //PowerMenu already exist

        delete iMemCardPwdDialog;

        iMemCardPwdDialog = NULL;

        }

    if ( iSapTimer )

        {

        iSapTimer->Cancel();

        delete iSapTimer;

        }

    //Powermenu

    if (iPowerMenuDialog!=NULL)

        {

        //PowerMenu already exist

        delete iPowerMenuDialog;

        iPowerMenuDialog = NULL;

        }

    RWindowGroup groupWin = iCoeEnv->RootWin();

    groupWin.CancelCaptureKey( iCapturedEKeyPowerOff );

    groupWin.CancelCaptureKeyUpAndDowns( iCapturedEKeyPowerOffUpAndDowns );

    delete iSysApDefaultKeyHandler;

    delete iSysApCenRepLightSettingsObserver;

    delete iSysApCenRepBtObserver;

    delete iSysApCenRepHacSettingObserver;

    delete iSysApCenRepController;

    delete iSysApPubSubObserver;

    delete iSysApLightsController;

    delete iSysApFeatureManager;

    delete iSysApCenRepLogsObserver;

    delete iSysApOfflineModeController;

    delete iSysApUsbIndicatorController;

    delete iKeyguardController;

    delete iHbIndicatorSymbian; 

    delete iSysApKeyManagement;

    iSysApKeyManagement = NULL;

    REComSession::FinalClose();

    iResourcesFreed = ETrue;

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

    }

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

// CStartupAppUi::PrepareToExit()

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

void CSysApAppUi::PrepareToExit()

    {

    TRACES(RDebug::Print( _L("CSysApAppUi::PrepareToExit()")));

    CEikAppUi::PrepareToExit();

    }

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

// CSysApAppUi::StateOfProperty()

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

TInt CSysApAppUi::StateOfProperty( const TUid& aCategory, const TUint aKey ) const

    {

    TInt err( KErrNone );

    TInt value( 0 );

    err = RProperty::Get( aCategory, aKey, value );

    if ( err )

        {

        TRACES( RDebug::Print( _L("CSysApAppUi::StateOfProperty. RProperty::Get: err=%d"), err ) );

        return err;

        }

    return value;

    }

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

// CSysApAppUi::OfflineModeActive()

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

TBool CSysApAppUi::OfflineModeActive()

    {

    if(iSysApOfflineModeController)

        {

        return iSysApOfflineModeController->OfflineModeActive();

        }

    else

        {

        return EFalse;

        }

    }

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

// CSysApAppUi::GoOnlineL()

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

void CSysApAppUi::GoOnlineL( TBool /* aDoProfileChange */ )

    {

    if ( iSysApFeatureManager->OfflineModeSupported() )

        {

//        TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: going from off-line into on-line: aDoProfileChange=%d" ), aDoProfileChange ) );

        iActivateBt = iSysApOfflineModeController->MustBtBeActivated();

        iSysApOfflineModeController->SwitchFromOfflineToOnlineModeL();

        TRACES( RDebug::Print( _L("CSysApAppUi::GoOnlineL: iActivateBt = %d" ), iActivateBt ) );

        }

    }

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

// CSysApAppUi::GoOfflineL()

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

void CSysApAppUi::GoOfflineL()

    {

    if ( iSysApFeatureManager->OfflineModeSupported() )

        {

        TRACES( RDebug::Print( _L("CSysApAppUi::GoOfflineL" ) ) );

        iDeactivateBt = ETrue;

        iSysApOfflineModeController->SwitchFromOnlineToOfflineModeL();

        }

    }

#ifndef SYSAP_USE_STARTUP_UI_PHASE

// need to configure the above macro.

#else // SYSAP_USE_STARTUP_UI_PHASE

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

// CSysApAppUi::HandleUiReadyAfterBootL()

// Called when startup UI activities has been finished

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

void CSysApAppUi::HandleUiReadyAfterBootL()

    {

    TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL" ) ) );    

    TInt state( StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryLevel ) );

    UpdateBatteryBarsL( state );   

    DoSwStateNormalConstructionL();

    HandleAccessoryProfileInStartupL();

    if ( iSysApFeatureManager->MmcSupported() )

        {

#ifndef RD_MULTIPLE_DRIVE

        MountMMC();

        MMCStatusChangedL();

        iHideFirstBeep = EFalse;

#else // RD_MULTIPLE_DRIVE

		if(iSysApDriveList == NULL)

			{

				iSysApDriveList = CSysApDriveList::NewL( iEikonEnv->FsSession() );

			}

        iSysApDriveList->MountDrive( iSysApDriveList->DefaultMemoryCard() );

        UpdateInsertedMemoryCardsL();

#endif // RD_MULTIPLE_DRIVE

        }

	if ( iSysApFeatureManager->MmcHotSwapSupported() )

        {

        if(iSysApMMCObserver == NULL)

        	{

        	iSysApMMCObserver = CSysApMMCObserver::NewL(

            iEikonEnv->FsSession(), *iSysApDriveList, *this, iSysApFeatureManager->MmcHotSwapSupported() );

        	}

        iSysApMMCObserver->StartMountObserver();

        }    

    if ( !iSysApPsmController ) // created here if first state change has not occurred yet

       {

       iSysApPsmController = CSysApPsmController::NewL( *this );        

       }

    if ( iSysApPsmController )

       {

	   if ( iCharging ) // if charger is connected on boot PSM queries may need to be shown

        {

         HandleChargingStatusL( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) );

        }