#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 <wlaninternalpskeys.h> 

#include <HbDeviceNotificationDialogSymbian.h>

//#include <HbDeviceInputDialogSymbian.h>

#include <hbsymbianvariant.h>

#include <UikonInternalPSKeys.h>

//#include "SysApWsClient.h"

#include "SysApFeatureManager.h"

#include "SysApNspsHandler.h"

#include "sysapdefaultkeyhandler.h"

#include "SysApStartupController.h"

#include "MSysApOfflineModeController.h"

#include "SysApCenRepController.h"

#include "sysapaudioroutingobserver.h"

#include "sysapbatteryinfocontroller.h"

#include "SysApSimChanged.h"

#include "MSysApBtSapController.h"

#include "SysApShutdownImage.h"

#include <settingsinternalcrkeys.h>

#include <keyguardaccessapi.h>

#include <eikdef.h>

#include <eikenv.h>

class CHbSymbianVariant;

const TInt KDelayBeforeNextScanningRound( 1000000 );

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

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

    BaseConstructL();

    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...     

            }

         }

     iSysApUsbChargerDetector.EnableUsbCharging(

         iSysApFeatureManager->Supported( KSysApFeatureIdChargerReminderNotes ) &&

         iSysApFeatureManager->Supported( KSysApFeatureIdUsbChargingWithoutReminderNotes ) );

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

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

    iSysApFeatureManager->FeatureVariationCheckDone();        

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

    //Trap constuction, since Sysap may live without iSysApKeyManagement

        {

        TRACES( RDebug::Print( _L("CSysApAppUi::ConstructL : CSysApKeyManagement::NewL returns error=%d"), keyManagementErr ) );

        }

    iKeyguardController = CKeyguardAccessApi::NewL();

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

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

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

    {

    TRACES("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 ( iSysApPsmController )

        {

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

            {

            HandleChargingStatusL( StateOfProperty( KPSUidHWRMPowerState, KHWRMChargingStatus ) );

            }

        }

    TInt batteryStatus = StateOfProperty( KPSUidHWRMPowerState, KHWRMBatteryStatus );

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

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

        {

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

        HandleBatteryStatusL( batteryStatus );

        }

    else if ( iSysApPsmController && !iCharging )

        {

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

            iSysApPsmController->BatteryLow( EFalse );

            iSysApPsmController->DoEnablePartialPsm( EFalse );

        }

    if ( ! iSysApUsbIndicatorController )

        {

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

        if ( usbErr )

            {

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

            }

        }

   }

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

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

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

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

    {

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

    TRAPD( simChangedErr, DoSimChangedFromPreviousBootL() );

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

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

    LogsObserverL().HandleSimChangedCheckDoneL();

    if ( iSysApFeatureManager->PowerSaveSupported() )

        {

        // create controller before checking battery state, so that power saving can be enabled during boot if needed

        if ( !iSysApPsmController ) // created only in first state change

            {

            iSysApPsmController = CSysApPsmController::NewL( *this );        

            }

        // in charger boot explicitly disable 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 );

            }

        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

      {

      }