/*

* Copyright (c) 2002-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:  AppUi class of the application.

*

*/

// SYSTEM INCLUDES

#include <StringLoader.h>

#include <featmgr.h>                // Feature Manager

#include <centralrepository.h>

#include <startup.rsg>

#include <starterdomaincrkeys.h>

#include "startupappprivatepskeys.h"

#include <startupdomainpskeys.h>

#include <startupdomaincrkeys.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <starterclient.h>

#include <hbdevicemessageboxsymbian.h>

#include "sanimstartupctrl.h"

#include <apgtask.h>

// USER INCLUDES

#include "StartupAppUi.h"

#include "StartupApplication.h"

#include "StartupPubSubObserver.h"

#include "startupanimationwrapper.h"

#include "startupview.h"

#include <eikenv.h>

static const CSAnimStartupCtrl::TAnimationParams KStartupAnimationParams =

    {

    KCRUidStartupConf,

    KStartupAnimationPath,

    KStartupAnimationFrameDelay,

    KStartupAnimationScaling,

    KStartupTonePath,

    KStartupToneVolume

    };

_LIT_SECURITY_POLICY_C1(KReadDeviceDataPolicy, ECapabilityReadDeviceData);

_LIT_SECURITY_POLICY_C1(KWriteDeviceDataPolicy, ECapabilityWriteDeviceData);

_LIT_SECURITY_POLICY_PASS(KAlwaysPassPolicy);

// ======== LOCAL FUNCTIONS ==================================================

namespace

    {

    TInt AnimationFinishedFunc( TAny* aPtr )

        {

        static_cast<CStartupAppUi*>( aPtr )->AnimationFinished();

        return KErrNone;

        }

    }

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

//

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

// CStartupAppUi::CStartupAppUi()

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

CStartupAppUi::CStartupAppUi() :

   iInternalState( EStartupStartingUp ),

    iStartupFirstBootAndRTCCheckAlreadyCalled( EFalse ),

    iChargingOrAlarmBoot( EFalse ),

    iFirstBoot( ETrue ),

    iCleanBoot( EStartupNormalBoot ),

    iOfflineModeSupported( EFalse ),

    iOfflineModeQueryShown( EFalse ),

    iCriticalBlockEnded( EFalse ),

    iSwStateFatalStartupError( EFalse ),

    iStartupWaitingShowStartupAnimation( EFalse ),

    iSimSupported( ETrue )

    {

    TRACES("CStartupAppUi::CStartupAppUi");

    }

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

// CStartupAppUi::ConstructL()

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

void CStartupAppUi::ConstructL()

    {

    RThread thread; //increase the thread priority to smooth the animation

    thread.SetPriority(EPriorityAbsoluteForeground);

    thread.Close();

    TRACES("CStartupAppUi::ConstructL()");

    TInt flags = EStandardApp;

   BaseConstructL( flags );

    iMainView = CStartupView::NewL( ApplicationRect() );

    iAnimation = CStartupAnimationWrapper::NewL( *iMainView );

    TInt err = RProperty::Define( KPSUidStartupApp,

                                  KPSStartupAppState,

                                  RProperty::EInt,

                                  KReadDeviceDataPolicy,

                                  KWriteDeviceDataPolicy );

    if( KErrNone != err &&

        KErrAlreadyExists != err )

        {

        TRACES1("CStartupAppUi::ConstructL(): KPSStartupAppState define err %d", err);

        }

    err = RProperty::Set( KPSUidStartupApp,

                          KPSStartupAppState,

                          EStartupAppStateWait );

    if( KErrNone != err )

        {

        TRACES1("CStartupAppUi::ConstructL(): KPSStartupAppState set err %d", err);

        }

    iStartupPubSubObserver = CStartupPubSubObserver::NewL( this );

    err = RProperty::Define( KPSUidStartup,

                             KPSStartupUiPhase,

                             RProperty::EInt, 

                             KAlwaysPassPolicy,

                             KWriteDeviceDataPolicy );

    if( KErrNone != err &&

        KErrAlreadyExists != err )

        {

        TRACES1("CStartupAppUi::ConstructL(): KPSStartupUiPhase define err %d", err);       

        }

    UpdateStartupUiPhase( EStartupUiPhaseUninitialized );

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

        {

        iOfflineModeSupported = ETrue;

        }

    if ( !FeatureManager::FeatureSupported( KFeatureIdSimCard ) )

        {

        iSimSupported = EFalse;

        }

    TRACES1("CStartupAppUi::ConstructL(): Offline mode supported: %d", iOfflineModeSupported );

    TRACES1("CStartupAppUi::ConstructL(): SIM card supported:     %d", iSimSupported );

    iFirstBoot = FirstBoot();

    TRACES1("CStartupAppUi::ConstructL(): First boot:             %d", iFirstBoot );

    CEikonEnv* eikEnv = CEikonEnv::Static();

    // Set Startup application to be system application

    eikEnv->SetSystem( ETrue );

    eikEnv->RootWin().SetOrdinalPosition(0,0);

    // Disable priority changes of window server

    eikEnv->WsSession().ComputeMode(

        RWsSession::EPriorityControlDisabled );

   iNoteTimer = CPeriodic::NewL( EPriorityNormal );

    iExitTimer = CPeriodic::NewL( EPriorityNormal );

    if ( iSwStateFatalStartupError )

        {

        TRACES("CStartupAppUi::ConstructL(): ESWStateFatalStartupError");

        DoNextStartupPhaseL( EStartupSystemFatalError );

        TRACES("CStartupAppUi::ConstructL(): End, Boot failed");

        return;//Execution stops here.

        }

    DoStartupStartPartL();

    TRACES("CStartupAppUi::ConstructL(): End");

    }

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

// CStartupAppUi::~CStartupAppUi()

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

CStartupAppUi::~CStartupAppUi()

    {

    TRACES("CStartupAppUi::~CStartupAppUi()");

    if( iExitTimer )

        {

        iExitTimer->Cancel();

        delete iExitTimer;

        }

    if( iNoteTimer )

        {

        iNoteTimer->Cancel();

        delete iNoteTimer;

        }

    delete iAnimation;

    delete iStartupPubSubObserver;

    delete iMainView;

    FeatureManager::UnInitializeLib();

    TRACES("CStartupAppUi::~CStartupAppUi(): End");

    }

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

// CStartupAppUi::PrepareToExit()

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

void CStartupAppUi::PrepareToExit()

    {

    TRACES("CStartupAppUi::PrepareToExit()");

	CEikAppUi::PrepareToExit();

#ifndef RD_BOOT_CUSTOMIZABLE_AI

    if( !iChargingOrAlarmBoot )

        {

        TRACES("CStartupAppUi::PrepareToExit(): NOT Charger/alarm boot");

        TRACES("CStartupAppUi::PrepareToExit(): Activate Idle app");

        TVwsViewId viewId = TVwsViewId(TUid::Uid(0x101FD64C), TUid::Uid(0x101FD64C));

        TUid customMessageUid = KNullUid;

        TRAPD(ignore, CreateActivateViewEventL(viewId, customMessageUid, KNullDesC8()));

        if (ignore != KErrNone)

            {

            TRACES1("CStartupAppUi::PrepareToExit(): CreateActivateViewEventL() leaves, err = %d", ignore );

            }

        }

#endif //RD_BOOT_CUSTOMIZABLE_AI

    TRACES("CStartupAppUi::PrepareToExit(): End");

    }

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

// CStartupAppUi::DoStopTimingL(TAny* aObject)

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

TInt CStartupAppUi::DoStopTimingL(TAny* aObject)

    {

    TRACES("CStartupAppUi::DoStopTimingL() +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");

    TRACES1("CStartupAppUi::DoStopTimingL(): Object: %d", aObject);

    STATIC_CAST( CStartupAppUi*, aObject )->StopTimingL(); // cast, and call non-static function

    TRACES("CStartupAppUi::DoStopTimingL(): End ------------------------------------------------------ ");

    return KErrNone;

    }

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

// CStartupAppUi::DoExitApplication(TAny* aObject)

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

TInt CStartupAppUi::DoExitApplication(TAny* aObject)

    {

    TRACES("CStartupAppUi::DoExitApplication()");

    STATIC_CAST( CStartupAppUi*, aObject )->ExitApplication(); // cast, and call non-static function

    TRACES("CStartupAppUi::DoExitApplication(): End");

    return KErrNone;

    }

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

// CStartupAppUi::HandleKeyEventL

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

TKeyResponse CStartupAppUi::HandleKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    TRACES3("CStartupAppUi::HandleKeyEventL(): code = %d, type = %d, repeats = %d",

        aKeyEvent.iCode, aType, aKeyEvent.iRepeats);

    TKeyResponse response( EKeyWasNotConsumed );

    if ( aType != EEventNull &&

         aKeyEvent.iCode == EKeyApplication0 && // Apps key

         ( iInternalState == EStartupShowingWelcomeAnimation ||

           iInternalState == EStartupShowingOperatorAnimation ||

           iInternalState == EStartupShowingUserWelcomeNote ) )

        {

        if ( aKeyEvent.iRepeats && iCleanBoot != EStartupCleanBoot)

            {

            // Long apps key press detected. Set clean boot.

            SetCleanBoot();

            }

        response = EKeyWasConsumed;

        }

    else if ( aType != EEventNull &&

              aKeyEvent.iCode != EStdKeyNull &&

              aType == EEventKeyDown )

        {

        TRACES("CStartupAppUi::HandleKeyEventL(): Event code is EEventKeyDown");

        if ( iOfflineModeQueryShown )

            {

            TRACES("CStartupAppUi::HandleKeyEventL(): First key event comes from Offline Mode Query");

            // first key event comes from Offline Mode Query

            iOfflineModeQueryShown = EFalse;

            response = EKeyWasConsumed;

            }

        else if ( ( iInternalState == EStartupShowingWelcomeAnimation ||

                    iInternalState == EStartupShowingOperatorAnimation ) &&

                   !( iAnimation->WasCancelled() ) )

            {

            TRACES("CStartupAppUi::HandleKeyEventL(): This key event is used to cancel animations");

            CancelAnimation();

            response = EKeyWasConsumed;

            }

        }

    TRACES1("CStartupAppUi::HandleKeyEventL(): End, return %d", response);

    return response;

    }

/*

 * Qt Support Not available..

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

// CStartupAppUi::HandleResourceChangeL

//

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

//

void CStartupAppUi::HandleResourceChangeL( TInt aType )

    {

    TRACES("CStartupAppUi::HandleResourceChangeL()");

    TRACES1("CStartupAppUi::HandleResourceChangeL Type: %d", aType);

     * No equivalent in Qt. 

    CAknAppUi::HandleResourceChangeL( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        iMainView->SetRect( ApplicationRect() );

        }

    TRACES("CStartupAppUi::HandleResourceChangeL(): End");

    }

*/

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

// CStartupAppUi::HandleCommandL(TInt aCommand)

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

void CStartupAppUi::HandleCommandL(TInt aCommand)

    {

    TRACES("CStartupAppUi::HandleCommandL()");

    switch (aCommand)

        {

        case EEikCmdExit:

            {

            TRACES("CStartupAppUi::HandleCommandL(): EEikCmdExit");

			Exit();

            }

            break;

        default:

            break;

        }//End of switch-clause

    TRACES("CStartupAppUi::HandleCommandL(): End");

    }

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

// CStartupAppUi::DoStartupStartPartL()

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

void CStartupAppUi::DoStartupStartPartL()

    {

    TRACES("CStartupAppUi::DoStartupStartPartL()");

    TryPreLoadAnimation();

    DoNextStartupPhaseL( EStartupWaitingCriticalBlock );

    TRACES("CStartupAppUi::DoStartupStartPartL(): End");

    }

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

// CStartupAppUi::TryPreLoadAnimation()

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

void CStartupAppUi::TryPreLoadAnimation()

    {

    TRACES("CStartupAppUi::TryPreLoadAnimation()");

    TInt state( ESwStateStartingCriticalApps );

    TInt err;

    err = RProperty::Get( KPSUidStartup, KPSGlobalSystemState, state ); // Use default if this fails

    if( KErrNone != err )

        {

        TRACES1("CStartupAppUi::TryPreLoadAnimation(): KPSGlobalSystemState get err %d", err);

        }

    TInt mode( EStartupModeNormal );

    err = RProperty::Get( KPSUidStartup, KPSGlobalStartupMode, mode ); // Use default if this fails

    if( KErrNone != err )

        {

        TRACES1("CStartupAppUi::TryPreLoadAnimation(): KPSGlobalStartupMode get err %d", err);

        }

    TRACES2("CStartupAppUi::TryPreLoadAnimation(): State: %d, mode %d", state, mode);

    if ( ( !HiddenReset() || iFirstBoot ) && // First boot or not-a-reset

         ( ( ( state == ESwStateStartingCriticalApps || state == ESwStateSelfTestOK ) &&

           mode == EStartupModeNormal ) || // Not going to charging or alarm mode

         state == ESwStateSecurityCheck ) )

        {

        iAnimation->PreLoad(

            ClientRect(),

			*iMainView,

            KStartupAnimationParams,

            ETrue,

            SecondaryDisplay::EStartWelcomeAnimation );

        }

    TRACES("CStartupAppUi::TryPreLoadAnimation(): End");

    }

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

// CStartupAppUi::DoStartupShowWelcomeAnimationL()

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

void CStartupAppUi::DoStartupShowWelcomeAnimationL()

    {

    TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL()");

    if ( HiddenReset() )

        {

        //skip the welcome animation and user welcome note and continue with

        //the same way like in the end of ShowUserWelcomeNoteL()

        TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): Skip the animation and UWN because it's hidden reset");

        TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): and change internal state directly to EStartupFirstBootAndRTCCheck");

        DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );

        }

    else

        {

        TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): Show animation");

        iAnimation->Play(

            ClientRect(),

			*iMainView,

            KStartupAnimationParams,

            ETrue,

            SecondaryDisplay::EStartWelcomeAnimation,

            TCallBack( AnimationFinishedFunc, this ) );

        }

    TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): End");

    }

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

// CStartupAppUi::DoStartupShowOperatorAnimationL()

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

void CStartupAppUi::DoStartupShowOperatorAnimationL()

    {

    TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL()");

    if ( HiddenReset() )

        {

        //skip the operator animation and user welcome note and continue with

        //the same way like in the end of ShowUserWelcomeNoteL()

        TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): Skip the animation and UWN because it's hidden reset");

        TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): and change internal state directly to EStartupFirstBootAndRTCCheck");

        DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );

        }

    else

        {

        TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): Show animation");

        CSAnimStartupCtrl::TAnimationParams params;

        params.iRepositoryUid = KCRUidStartupConf;

        params.iAnimationPathKey = KStartupOperatorAnimationPath;

        params.iFrameDelayKey = KStartupOperatorAnimationFrameDelay;

        params.iEnableScalingKey = KStartupOperatorAnimationScaling;

        params.iTonePathKey = KStartupOperatorTonePath;

        params.iVolumeKey = KStartupOperatorToneVolume;

        iAnimation->Play(

            ClientRect(),

            *iMainView,

            params,

            EFalse,

            SecondaryDisplay::EStartOperatorAnimation,

            TCallBack( AnimationFinishedFunc, this ) );