/*

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

#include <hbsymbianvariant.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 <settingsinternalcrkeys.h>

#include <keyguardaccessapi.h>

#include <eikdef.h>

#include <eikenv.h>

class CHbSymbianVariant;

const TInt KModifierMask( 0 );

_LIT_SECURITY_POLICY_PASS(KAlwaysPassPolicy);

_LIT_SECURITY_POLICY_C1(KWriteDeviceDataPolicy, ECapabilityWriteDeviceData);

const TInt KDelayBeforeNextScanningRound( 1000000 );

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

_LIT(KPsm,"PSM");

_LIT(KCharging,"Charging");

_LIT(KPsmlocalisationfile, "powermanagement_");

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

_LIT(KlowbatteryIcon,"qtg_small_bt_low_battery.svg");

_LIT(KbatteryFullIcon,"qtg_status_battery.svg");

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

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

// CSysApAppUi::CSysApAppUi()

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

CSysApAppUi::CSysApAppUi()

    :iSysApShutdownImage(NULL),

     iPowerMenuDialog(NULL),

     iDeviceLockEnabled(EFalse),

     iKeyLockEnabled(EFalse),

     iPowerKeyPopupMenuActive(EFalse),

     iResourcesFreed (EFalse),

     iShutdownStarted (EFalse),

     iSysApAudioRoutingObserver (NULL),

     iSysApBatteryInfoController (NULL),

     iSysApPsmController(NULL),

     iSapTimer (NULL),

     iSysApCenRepLogsObserver (NULL),

     iSysApUsbIndicatorController(NULL),

     iKeyguardController (NULL),

     iKeyLockOnBeforeCall (EFalse),

     iCheckLongPowerKeyEvent (EFalse)

	{

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

    }

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

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

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

        }

    // 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: END") ) );    

    }

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

// CSysApAppUi::FreeResources()

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

void CSysApAppUi::FreeResources()

    {

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

    delete iSysApBatteryInfoController;

    delete iSysApPsmController;

    delete iSysApAudioRoutingObserver;

    if ( iSapTimer )

        {

        iSapTimer->Cancel();

        delete iSapTimer;

        }

    //Powermenu

    if (iPowerMenuDialog!=NULL)

        {

        //PowerMenu already exist

        delete iPowerMenuDialog;

        iPowerMenuDialog = NULL;

        }

    RWindowGroup groupWin = iCoeEnv->RootWin();

    groupWin.CancelCaptureKey( iCapturedEKeyPowerOff );

    groupWin.CancelCaptureKeyUpAndDowns( iCapturedEKeyPowerOffUpAndDowns );

    delete iSysApDefaultKeyHandler;

    delete iSysApCenRepLightSettingsObserver;

    delete iSysApCenRepBtObserver;

    delete iSysApCenRepHacSettingObserver;

    delete iSysApCenRepController;

    delete iSysApPubSubObserver;

    delete iSysApLightsController;

    delete iSysApFeatureManager;

    delete iSysApCenRepLogsObserver;

    delete iSysApOfflineModeController;

    delete iSysApUsbIndicatorController;

    delete iKeyguardController;

    delete iSysApKeyManagement;

    iSysApKeyManagement = NULL;

    REComSession::FinalClose();

    iResourcesFreed = ETrue;

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

    }

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

// CStartupAppUi::PrepareToExit()

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

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

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

       {

       iSysApPsmController = CSysApPsmController::NewL( *this );        

       }

    if ( iSysApPsmController )

       {

        {

         HandleChargingStatusL( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) );

        }

       }

    TInt batteryStatus = StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryStatus );

    TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: batteryStatus %d" ), batteryStatus ) );

    if(  batteryStatus == EBatteryStatusLow || batteryStatus == EBatteryStatusEmpty )

        {

        // low and empty battery states are informed to the user in device startup

        HandleBatteryStatusL( batteryStatus );

        }

    else if ( iSysApPsmController && !iCharging )

        {

            TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: batteryStatus %d, iCharging %d -> disable partial psm" ), batteryStatus, iCharging ) );

            iSysApPsmController->BatteryLow( EFalse );

            iSysApPsmController->DoEnablePartialPsm( EFalse );

        }

    if ( ! iSysApUsbIndicatorController )

        {

        TRAPD ( usbErr, iSysApUsbIndicatorController = CreateSysApUsbIndicatorL( *this ) );

        if ( usbErr )

            {

            TRACES( RDebug::Print(_L("CSysApAppUi::HandleUiReadyAfterBootL: error in constructing USB ind. controller %d" ), usbErr ) );

            }

        }

   }

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

// CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState)

// This method is not called after boot has finished.

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

void CSysApAppUi::DoStateChangedL(const RStarterSession::TGlobalState aSwState)

    {

    TRACES( RDebug::Print(_L("CSysApAppUi::DoStateChangedL: %d" ), aSwState ) );

    TRAPD( simChangedErr, DoSimChangedFromPreviousBootL() );

    TRACES( RDebug::Print( _L("CSysApAppUi::DoStateChangedL: simChangedErr = %d" ), simChangedErr ) );

    simChangedErr = simChangedErr; // suppress 'variable not used' warning