/*

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

#include <badesca.h>

#include <tzlocalizationdatatypes.h>

#include <tzlocalizer.h>

#include <tz.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>

#ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

// Transition effects

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntranseffect.h>

#endif

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

  #include "sanimstartupctrl.h"

#else // RD_STARTUP_ANIMATION_CUSTOMIZATION

  #include <akndef.h>                 // For layout change event definitions

  #include <AknSoundSystem.h>

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

// USER INCLUDES

#include "StartupAppUi.h"

#include "StartupApplication.h"

#include "StartupUserWelcomeNote.h"

#include "StartupQueryDialog.h"     //used for Startup own Time and Date queries

#include "StartupPopupList.h"       //used for Startup own City and Country queries

#include "StartupMediatorObserver.h"

#include "StartupPubSubObserver.h"

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

  #include "startupanimationwrapper.h"

  #include "startupview.h"

#else // RD_STARTUP_ANIMATION_CUSTOMIZATION

  #include "StartupDocument.h"

  #include "StartupOperatorAnimation.h"

  #include "StartupTone.h"

  #include "StartupWelcomeAnimation.h"

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

// CONSTANTS

const TInt KUserWelcomeNoteShowPeriodTime = 3000000; // 3 sec

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

  const TInt KOneMilliSecondInMicroSeconds = 1000;

  const TInt KMaxToneInitWait = 200; // 200 ms

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

static const TInt KMaxCityLength(120);

static const TInt KMaxCountryLength(120);

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

static const CSAnimStartupCtrl::TAnimationParams KStartupAnimationParams =

    {

    KCRUidStartupConf,

    KStartupAnimationPath,

    KStartupAnimationFrameDelay,

    KStartupAnimationScaling,

    KStartupTonePath,

    KStartupToneVolume

    };

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

_LIT(KEmpty, " ");

// Default date and time value is used if cenrep string is not valid

// Default date is 01.01.2007 and default time is 09:00 AM

_LIT( KDefaultDateTimeValue, "20070000:090000" ); // YYYYMMDD:HHMMSS

static const TInt KTimeFormatLength(16); // "20070000:090000."

_LIT_SECURITY_POLICY_C1(KReadDeviceDataPolicy, ECapabilityReadDeviceData);

_LIT_SECURITY_POLICY_C1(KWriteDeviceDataPolicy, ECapabilityWriteDeviceData);

_LIT_SECURITY_POLICY_PASS(KAlwaysPassPolicy);

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

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

namespace

    {

    TInt AnimationFinishedFunc( TAny* aPtr )

        {

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

        return KErrNone;

        }

    }

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

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

//

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

// CStartupAppUi::CStartupAppUi()

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

CStartupAppUi::CStartupAppUi() :

    iUserWelcomeNote( NULL ),

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    iStartupTone( NULL ),

    iOpStartupTone( NULL ),

    iToneInitWaitTime( 0 ),

    iAnimation( EFalse ),

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    iInternalState( EStartupStartingUp ),

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    iSplashScreenShouldBeRemoved( EFalse ),

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    iStartupFirstBootAndRTCCheckAlreadyCalled( EFalse ),

    iChargingOrAlarmBoot( EFalse ),

    iFirstBoot( ETrue ),

    iCleanBoot( EStartupNormalBoot ),

    iOfflineModeSupported( EFalse ),

    iOfflineModeQueryShown( EFalse ),

    iCriticalBlockEnded( EFalse ),

    iSwStateFatalStartupError( EFalse ),

    iStartupWaitingShowStartupAnimation( EFalse ),

    iSimSupported( ETrue ),

    iStartupMediatorObserver( NULL ),

    iCoverUISupported( EFalse ),

    iCounryListIndex( 0 )

    , iTime( 0 )

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    , iTouchScreenCalibSupport( EFalse )

    , iTouchScreenCalibrationDone( EFalse )

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    {

    TRACES("CStartupAppUi::CStartupAppUi");

    }

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

// CStartupAppUi::ConstructL()

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

void CStartupAppUi::ConstructL()

    {

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

    TInt flags = EStandardApp|EAknEnableSkin|EAknEnableMSK ;

    BaseConstructL(flags);

    iAvkonAppUi->SetKeyEventFlags( CAknAppUiBase::EDisableSendKeyShort |

                                   CAknAppUiBase::EDisableSendKeyLong );

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

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

    iAnimation = CStartupAnimationWrapper::NewL( *iMainView );

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

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

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    err = RProperty::Define( KPSUidStartup,

                             KStartupBootIntoOffline,

                             RProperty::EInt,

                             KReadDeviceDataPolicy,

                             KWriteDeviceDataPolicy );

    if( KErrNone != err &&

        KErrAlreadyExists != err )

        {

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

        }

    err = RProperty::Define( KPSUidStartup,

                             KStartupSecurityCodeQueryStatus,

                             RProperty::EInt,

                             KReadDeviceDataPolicy,

                             KWriteDeviceDataPolicy );

    if( KErrNone != err &&

        KErrAlreadyExists != err )

        {

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

        }

    err = RProperty::Define( KPSUidStartup,

                             KStartupCleanBoot,

                             RProperty::EInt,

                             KReadDeviceDataPolicy,

                             KWriteDeviceDataPolicy );

    if( KErrNone != err &&

        KErrAlreadyExists != err )

        {

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

        }

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

    err = RProperty::Define( KPSUidStartup,

                             KPSStartupUiPhase,

                             RProperty::EInt, 

                             KAlwaysPassPolicy,

                             KWriteDeviceDataPolicy );

    if( KErrNone != err &&

        KErrAlreadyExists != err )

        {

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

        }

    UpdateStartupUiPhase( EStartupUiPhaseUninitialized );

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

        {

        iOfflineModeSupported = ETrue;

        }

    if ( !FeatureManager::FeatureSupported( KFeatureIdSimCard ) )

        {

        iSimSupported = EFalse;

        }

    if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )

        {

        iCoverUISupported = ETrue;

        }

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

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

    TRACES1("CStartupAppUi::ConstructL(): CoverUI supported:      %d", iCoverUISupported );

#if defined (RD_SCALABLE_UI_V2) && !defined(RD_STARTUP_ANIMATION_CUSTOMIZATION)

    if ( FeatureManager::FeatureSupported(KFeatureIdPenSupport) &&

         FeatureManager::FeatureSupported(KFeatureIdPenSupportCalibration) )

        {

        iTouchScreenCalibSupport = ETrue;

        }

#endif // RD_SCALABLE_UI_V2 && !RD_STARTUP_ANIMATION_CUSTOMIZATION

    if (iCoverUISupported)

        {

        iStartupMediatorObserver = CStartupMediatorObserver::NewL( this );

        }

    iFirstBoot = FirstBoot();

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

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    iWelcomeAnimation = CStartupWelcomeAnimation::NewL( this, ClientRect());

    AddToStackL( iWelcomeAnimation );

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    // Set Startup application to be system application

    iEikonEnv->SetSystem( ETrue );

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

    // Disable priority changes of window server

    iEikonEnv->WsSession().ComputeMode(

        RWsSession::EPriorityControlDisabled );

    iNoteTimer = CPeriodic::NewL( EPriorityNormal );

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    iAnimTimer = CPeriodic::NewL( EPriorityNormal );

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    iExitTimer = CPeriodic::NewL( EPriorityNormal );

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

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

    iStartupTone = CStartupTone::NewL( this, EStartupTone );

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

    TRACES("CStartupAppUi::ConstructL(): Operator StartupTone: Initialising");

    iOpStartupTone = CStartupTone::NewL( this, EStartupOpTone );

    TRACES("CStartupAppUi::ConstructL(): Operator StartupTone: Initialised");

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

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

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    if (iWelcomeAnimation)

        {

        RemoveFromStack( iWelcomeAnimation );

        delete iWelcomeAnimation;

        }

    if (iOperatorAnimation)

        {

        RemoveFromStack( iOperatorAnimation);

        delete iOperatorAnimation;

        }

    if (iUserWelcomeNote)

        {

        RemoveFromStack( iUserWelcomeNote );

        delete iUserWelcomeNote;

        iUserWelcomeNote = NULL;

        }

    if (iStartupPubSubObserver)

        {

        delete iStartupPubSubObserver;

        }

    if (iStartupMediatorObserver)

        {

        delete iStartupMediatorObserver;

        }

    if (iStartupTone)

        {

        delete iStartupTone;

        }

    if (iOpStartupTone)

        {

        delete iOpStartupTone;

        }

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    if( iExitTimer )

        {

        iExitTimer->Cancel();

        delete iExitTimer;

        }

#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION

    if( iAnimTimer )

        {

        iAnimTimer->Cancel();

        delete iAnimTimer;

        }

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    if( iNoteTimer )

        {

        iNoteTimer->Cancel();

        delete iNoteTimer;

        }

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

    delete iUserWelcomeNote;

    delete iAnimation;

    delete iStartupPubSubObserver;

    delete iStartupMediatorObserver;

    delete iMainView;

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

    FeatureManager::UnInitializeLib();

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

    }

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

// CStartupAppUi::PrepareToExit()

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

void CStartupAppUi::PrepareToExit()

    {

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

#ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

    // Start the custom exit effect at boot time.

    // Note: Not allowed to call GfxTransEffect::EndFullScreen() as AVKON takes care of that when

    // EApplicationExit context is used!

#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION

    if ( !( iAnimation->WasCancelled() ) )

#else // RD_STARTUP_ANIMATION_CUSTOMIZATION

    if( !iWelcomeAnimation->IsAnimationCancelled() )

#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION

        {

        TRACES("CStartupAppUi::PrepareToExit(): Starting transition effect");

        GfxTransEffect::BeginFullScreen( AknTransEffect::EApplicationExit, TRect(),

            AknTransEffect::EParameterType,

            AknTransEffect::GfxTransParam( KUidStartUp, AknTransEffect::TParameter::EAllowAtBoot ) );

        }

#endif

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

            {

            TRACES("CStartupAppUi::HandleKeyEventL(): This key event is used to stop UserWelcomeAnimation");

            //this is used to stop User Welcome note showing

            StopTimingL();

            response = EKeyWasConsumed;

            }

        else if ( ( iInternalState == EStartupShowingWelcomeAnimation ||

                    iInternalState == EStartupShowingOperatorAnimation ) &&

                   !( iAnimation->WasCancelled() ) )

            {

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