MCL/sf/mw/appsupport: comparison startupservices/Startup/src/StartupAppUi.cpp

equal deleted inserted replaced

-:924385140d98
+:c2c61fdca848
 /*
-* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2002-2008 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".
 */
 // SYSTEM INCLUDES
 #include <StringLoader.h>
+#include <AknGlobalNote.h>          //used for Selftest failed note
+#include <aknPopup.h>
+#include <aknlists.h>
+#include <aknSDData.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>
-#include <hbdevicemessageboxsymbian.h>
+#include "StartupWelcomeCrKeys.h"
-#include "sanimstartupctrl.h"
-#include <apgtask.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"
-#include "startupanimationwrapper.h"
-#include "startupview.h"
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
+#include "startupanimationwrapper.h"
-#include <eikenv.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() :
-iInternalState( EStartupStartingUp ),
+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 )
+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()
 {
-RThread thread; //increase the thread priority to smooth the animation
-thread.SetPriority(EPriorityAbsoluteForeground);
-thread.Close();
 TRACES("CStartupAppUi::ConstructL()");
-TInt flags = EStandardApp;
+TInt flags = EStandardApp|EAknEnableSkin|EAknEnableMSK ;
-BaseConstructL( flags );
+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,
 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 );
 {
 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
-CEikonEnv* eikEnv = CEikonEnv::Static();
+iWelcomeAnimation = CStartupWelcomeAnimation::NewL( this, ClientRect());
+AddToStackL( iWelcomeAnimation );
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // Set Startup application to be system application
-eikEnv->SetSystem( ETrue );
+iEikonEnv->SetSystem( ETrue );
-eikEnv->RootWin().SetOrdinalPosition(0,0);
+iEikonEnv->RootWin().SetOrdinalPosition(0,0);
 // Disable priority changes of window server
-eikEnv->WsSession().ComputeMode(
+iEikonEnv->WsSession().ComputeMode(
 RWsSession::EPriorityControlDisabled );
-iNoteTimer = CPeriodic::NewL( EPriorityNormal );
+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 );
 // ---------------------------------------------------------------------------
 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");
 }
 // ---------------------------------------------------------------------------
 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
-	CEikAppUi::PrepareToExit();
+// 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::DoExitApplication()");
 STATIC_CAST( CStartupAppUi*, aObject )->ExitApplication(); // cast, and call non-static function
 TRACES("CStartupAppUi::DoExitApplication(): End");
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // CStartupAppUi::HandleKeyEventL
 // ---------------------------------------------------------------------------
 TKeyResponse CStartupAppUi::HandleKeyEventL(
 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");
 TRACES1("CStartupAppUi::HandleKeyEventL(): End, return %d", response);
 return response;
 }
-/*
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
-* 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");
 }
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
-*/
 // ---------------------------------------------------------------------------
 // CStartupAppUi::HandleCommandL(TInt aCommand)
 // ---------------------------------------------------------------------------
 switch (aCommand)
 {
 case EEikCmdExit:
 {
 TRACES("CStartupAppUi::HandleCommandL(): EEikCmdExit");
+Exit();
-			Exit();
 }
 break;
 default:
 break;
 }//End of switch-clause
 // CStartupAppUi::DoStartupStartPartL()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::DoStartupStartPartL()
 {
 TRACES("CStartupAppUi::DoStartupStartPartL()");
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 TryPreLoadAnimation();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 DoNextStartupPhaseL( EStartupWaitingCriticalBlock );
 TRACES("CStartupAppUi::DoStartupStartPartL(): End");
 }
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ---------------------------------------------------------------------------
 // CStartupAppUi::TryPreLoadAnimation()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::TryPreLoadAnimation()
 {
 mode == EStartupModeNormal ) || // Not going to charging or alarm mode
 state == ESwStateSecurityCheck ) )
 {
 iAnimation->PreLoad(
 ClientRect(),
-			*iMainView,
+*iMainView,
 KStartupAnimationParams,
 ETrue,
 SecondaryDisplay::EStartWelcomeAnimation );
 }
 TRACES("CStartupAppUi::TryPreLoadAnimation(): End");
 }
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ---------------------------------------------------------------------------
 // CStartupAppUi::DoStartupShowWelcomeAnimationL()
 // ---------------------------------------------------------------------------
 {
 //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");
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iWelcomeAnimation->RemoveSplashScreen();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
-}
+return;
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+}
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 else
 {
 TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): Show animation");
 iAnimation->Play(
 ClientRect(),
-			*iMainView,
+*iMainView,
 KStartupAnimationParams,
 ETrue,
 SecondaryDisplay::EStartWelcomeAnimation,
 TCallBack( AnimationFinishedFunc, this ) );
 }
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): Play startup tone.");
+// Play startup tone
+if (iStartupTone->Play() != KErrNone)
+{
+// Play startup beep.
+TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): Play startup beep");
+static_cast<CAknAppUi*>(iEikonEnv->
+EikAppUi())->
+KeySounds()->
+PlaySound( EAvkonSIDPowerOnTone );
+}
+iWelcomeAnimation->SetAnimationShowing(ETrue);
+ShowWelcomeAnimationL();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): End");
 }
 // ---------------------------------------------------------------------------
 //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 );
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
-}
+return;
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+}
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 else
 {
 TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): Show animation");
 CSAnimStartupCtrl::TAnimationParams params;
 params.iEnableScalingKey = KStartupOperatorAnimationScaling;
 params.iTonePathKey = KStartupOperatorTonePath;
 params.iVolumeKey = KStartupOperatorToneVolume;
 iAnimation->Play(
 ClientRect(),
 *iMainView,
 params,
 EFalse,
 SecondaryDisplay::EStartOperatorAnimation,
 TCallBack( AnimationFinishedFunc, this ) );
 }
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+if ( iOperatorAnimation->ShowingTime() )
+{
+TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): Operator animation time defined properly");
+iOperatorAnimation->SetAnimationShowing(ETrue);
+iOpStartupTone->Play();
+ShowOperatorAnimationL();
+}
+else
+{
+TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): Operator animation not defined. Skip it.");
+iOperatorAnimation->SetAnimationShowing(EFalse);
+DoNextStartupPhaseL( EStartupShowingUserWelcomeNote );
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): End");
 }
+// ---------------------------------------------------------------------------
+// CStartupAppUi::DoStartupShowUserWelcomeNoteL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::DoStartupShowUserWelcomeNoteL()
+{
+TRACES("CStartupAppUi::DoStartupShowUserWelcomeNoteL()");
+ShowUserWelcomeNoteL();
+TRACES("CStartupAppUi::DoStartupShowUserWelcomeNoteL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::StartupQueriesEnabled()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::StartupQueriesEnabled()
+{
+TRACES("CStartupAppUi::StartupQueriesEnabled()");
+TInt value( EStartupQueriesEnabled );
+CRepository* repository(NULL);
+TRAPD( err, repository = CRepository::NewL( KCRUidStartupConf ) );
+if ( err == KErrNone )
+{
+err = repository->Get( KStartupQueries, value );
+}
+delete repository;
+TRACES1("CStartupAppUi::StartupQueriesEnabled(): returns %d", value);
+return value;
+}
 // ---------------------------------------------------------------------------
 // CStartupAppUi::PredictiveTimeEnabled()
 // ---------------------------------------------------------------------------
 TBool CStartupAppUi::PredictiveTimeEnabled()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::DoStartupFirstBootAndRTCCheckL()
 {
 TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL()");
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 RProperty::Set( KPSUidStartup, KStartupCleanBoot, iCleanBoot );
 RProperty::Set( KPSUidStartup, KPSSplashShutdown, ESplashShutdown );
+delete iUserWelcomeNote;
+iUserWelcomeNote = NULL;
 iMainView->DrawDeferred();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // When Predictive Time and Country Selection is enabled, no queries are
 // shown to user during first boot. Instead, Clock application gets the
 // time and location from the network and marks the first boot as done.
 if( !PredictiveTimeEnabled() )
 {
-if( iFirstBoot && !HiddenReset() ) //&& StartupQueriesEnabled() )
+if( iFirstBoot && !HiddenReset() && StartupQueriesEnabled() )
 {
 TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): First boot. Show city, time and date queries.");
-		    TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): Mark first boot");
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iWelcomeAnimation->UpdateDrawInfo( EStartupDICityTimeDateQueries );
+iWelcomeAnimation->DrawNow();
+if (iOperatorAnimation)
+{
+RemoveFromStack( iOperatorAnimation );
+delete iOperatorAnimation;
+iOperatorAnimation = NULL;
+}
+if (iUserWelcomeNote)
+{
+RemoveFromStack( iUserWelcomeNote );
+delete iUserWelcomeNote;
+iUserWelcomeNote = NULL;
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+ShowStartupQueriesL();
+TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): Mark first boot");
 MarkFirstBoot();
 }
-		else if( !RTCStatus() && !HiddenReset() ) // && StartupQueriesEnabled())
+else if( !RTCStatus() && !HiddenReset() && StartupQueriesEnabled())
 {
 TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): No first boot but RTCStatus is corrupted. Ask time and date");
-		     }
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
-		if( iFirstBoot )  // && !StartupQueriesEnabled() )
+iWelcomeAnimation->UpdateDrawInfo( EStartupDICityTimeDateQueries );
+if (iUserWelcomeNote)
+{
+RemoveFromStack( iUserWelcomeNote );
+delete iUserWelcomeNote;
+iUserWelcomeNote = NULL;
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+ShowStartupQueriesL(); // Not first boot, so skips Country/City query
+}
+if( iFirstBoot && !StartupQueriesEnabled() )
 {
 TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): First boot ongoing and queries are disabled.");
 MarkFirstBoot();
 }
 }
-	else
-		{
-		// Temporary fix for the defect VEZI-7YDEAR , as clock is not yet supported.
-		TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): if PredictiveTimeEnabled is set");
-		if( iFirstBoot && !HiddenReset() )
-		    {
-TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): Mark first boot");
-MarkFirstBoot();
-			}
-		// End of temporary fix.
-		}
 TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): Setting KPSStartupAppState = EStartupAppStateFinished");
 TInt err = RProperty::Set( KPSUidStartupApp, KPSStartupAppState, EStartupAppStateFinished );
 if( KErrNone != err )
 {
 TRACES1("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): KPSStartupAppState set err %d"
 , err);
 }
-DoNextStartupPhaseL( EStartupStartupOK );
+DoNextStartupPhaseL( EStartupWaitingCUIStartupReady );
 }
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowStartupQueriesL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::ShowStartupQueriesL()
+{
+TRACES("CStartupAppUi::ShowStartupQueriesL()");
+TBool citysaved(EFalse);
+TBool timesaved(EFalse);
+TBool datesaved(EFalse);
+// Get default time ( to be used only in date query )
+GetDefaultTimeAndDate( iTime );
+// Show Country, Date and Time queries ( with possibility to go back ).
+// Country query is shown only in the first boot.
+while (!timesaved)
+{
+while (!datesaved)
+{
+while (!citysaved && iFirstBoot)
+{
+// 1. Select time zone
+ShowCountryAndCityListsL();
+citysaved = ETrue;
+TRACES1("CStartupAppUi::ShowStartupQueriesL(): citysaved = %d", citysaved );
+}
+// 2. Set date
+datesaved = ShowDateQueryL();
+TRACES1("CStartupAppUi::ShowStartupQueriesL(): datesaved = %d", datesaved );
+if (!datesaved)
+{
+citysaved = EFalse;
+}
+}
+// 3. Set time
+timesaved = ShowTimeQueryL();
+TRACES1("CStartupAppUi::ShowStartupQueriesL(): timesaved = %d", timesaved );
+if (!timesaved)
+{
+datesaved = EFalse;
+}
+}
+// All the queries completed.
+TRACES("CStartupAppUi::ShowStartupQueriesL() - END");
+}
 // ---------------------------------------------------------------------------
 // CStartupAppUi::DoStartupEndPart()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::DoStartupEndPart()
 {
 TRACES("CStartupAppUi::DoStartupEndPart()");
 TRACES("CStartupAppUi::DoStartupEndPart(): STARTUP OK");
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+RProperty::Set( KPSUidStartup, KStartupCleanBoot, iCleanBoot );
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
+TBool fTUDone = ETrue;
+TRAP_IGNORE(IsFTUAvailableL(fTUDone));
-TBool ftuenabled=EFalse;
+if(fTUDone)
-TInt err=KErrNone;
+	{
-#ifndef __WINSCW__
+	UpdateStartupUiPhase( EStartupUiPhaseAllDone );
-TRAP(err,
+	}
-TInt enabled=0;
+	else
-//open cenrep;
+{
-CRepository *cenrep=CRepository::NewLC(KCRUidStartupConf);
+UpdateStartupUiPhase(EStartupUiPhaseAllDone+1);
-//check if ftu is enabled or not
+}
-User::LeaveIfError(cenrep->Get(KFtuStartupEnabled,enabled));
-ftuenabled=!!enabled; //make sure we only have a boolean value here
+//UpdateStartupUiPhase( EStartupUiPhaseAllDone );
-CleanupStack::PopAndDestroy(cenrep);
-);
-#endif
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
-if(!ftuenabled)
-{
-UpdateStartupUiPhase( EStartupUiPhaseAllDone );
-}
 TRACES("CStartupAppUi::DoStartupEndPart(): Exit application.");
 iExitTimer->Start( 100000, 100000, TCallBack( DoExitApplication, this ) );
 TRACES("CStartupAppUi::DoStartupEndPart(): DoExitApplication-timer called.");
 TRACES("CStartupAppUi::DoStartupEndPart(): End");
 }
+void CStartupAppUi::IsFTUAvailableL(TBool& aFTUAvailable)
+{
+	//From Startupwelcomecrkeys.h
+	CRepository* repo = CRepository::NewLC(KCRUidWelcome6);
+			repo->Get(KPhoneActicationCompleted, aFTUAvailable);
+			CleanupStack::PopAndDestroy(repo);
+}
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ContinueStartupAfterToneL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::ContinueStartupAfterToneL(TToneType aToneType)
+{
+TRACES("CStartupAppUi::ContinueStartupAfterToneL()");
+if (aToneType == EStartupTone)
+{
+TRACES("CStartupAppUi::ContinueStartupAfterToneL(): Tone type EStartupTone");
+DoNextStartupPhaseL( EStartupWaitingCUIOperatorAnim );
+}
+else if (aToneType == EStartupOpTone)
+{
+TRACES("CStartupAppUi::ContinueStartupAfterToneL(): Tone type EStartupOpTone");
+DoNextStartupPhaseL( EStartupShowingUserWelcomeNote );
+}
+else
+{
+TRACES("CStartupAppUi::ContinueStartupAfterToneL(): Tone interrupted");
+DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+}
+TRACES("CStartupAppUi::ContinueStartupAfterToneL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::BringToForeground()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::BringToForeground()
+{
+TRACES("CStartupAppUi::BringToForeground()");
+if ((iInternalState != EStartupWaitingTouchScreenCalib) ||
+(iTouchScreenCalibrationDone))
+{
+TRACES("CStartupAppUi::BringToForeground(): Bring to foreground");
+TApaTask self(iCoeEnv->WsSession());
+self.SetWgId(iCoeEnv->RootWin().Identifier());
+self.BringToForeground();
+}
+TRACES("CStartupAppUi::BringToForeground(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::SendToBackground()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::SendToBackground()
+{
+TRACES("CStartupAppUi::SendToBackground()");
+TApaTask self(iCoeEnv->WsSession());
+self.SetWgId(iCoeEnv->RootWin().Identifier());
+self.SendToBackground();
+TRACES("CStartupAppUi::SendToBackground(): End");
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ---------------------------------------------------------------------------
 // CStartupAppUi::StopTimingL()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::StopTimingL()
 //telling that timer has expired in appui so that
 //key pressed are not handled any more...
 TRACES("CStartupAppUi::StopTimingL(): Stopping UWN");
 iStartupFirstBootAndRTCCheckAlreadyCalled = ETrue;
 iNoteTimer->Cancel();
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 UpdateStartupUiPhase( EStartupUiPhaseUserWelcomeDone );
 DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+iUserWelcomeNote->CancelNoteCancelTimer();
+iWelcomeAnimation->UpdateDrawInfo( EStartupDIWelcomeNoteEnd );
+iWelcomeAnimation->DrawNow();
+iUserWelcomeNote->SetUserWelcomeNoteShowing(EFalse);
+TRACES("CStartupAppUi::StopTimingL(): UWN stopped");
+if (iStartupTone->Playing())
+{
+TRACES("CStartupAppUi::StopTimingL(): Startup tone playing. Cannot continue to next phase");
+iStartupTone->StartupWaiting(ETrue);
+}
+else
+{
+DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+}
+}
+else if (iInternalState == EStartupShowingOperatorAnimation)  // EStartupShowingOperatorAnimation
+{
+TRACES("CStartupAppUi::StopTimingL(): Stopping animation");
+iAnimTimer->Cancel();
+iWelcomeAnimation->CancelAnimCancelTimer();
+iOperatorAnimation->UpdateDrawInfo( EStartupDIOperatorAnimEnd );
+iOperatorAnimation->SetAnimationShowing(EFalse);
+TRACES("CStartupAppUi::StopTimingL(): operator animation showing stopped");
+if ( iOperatorAnimation->IsAnimationCancelled())
+{
+TRACES("CStartupAppUi::StopTimingL(): Animation is cancelled by user and therefore UWN is not shown");
+StopOperatorTone();
+iStartupFirstBootAndRTCCheckAlreadyCalled = ETrue;
+DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+}
+else
+{
+// If tone is still playing wait until it completes.
+if (iOpStartupTone->Playing())
+{
+TRACES("CStartupAppUi::StopTimingL(): Operator startup tone is still playing. Wait until it completes.");
+iOpStartupTone->StartupWaiting(ETrue);
+}
+else
+{
+TRACES("CStartupAppUi::StopTimingL(): Lets display UWN");
+DoNextStartupPhaseL( EStartupShowingUserWelcomeNote );
+}
+}
+TRACES("CStartupAppUi::StopTimingL(): Operator Animation stopped");
+}
+else // EStartupShowingWelcomeAnimation
+{
+TRACES("CStartupAppUi::StopTimingL(): Stopping animation");
+iAnimTimer->Cancel();
+iWelcomeAnimation->CancelAnimCancelTimer();
+iWelcomeAnimation->UpdateDrawInfo( EStartupDIWelcomeAnimEnd );
+iWelcomeAnimation->SetAnimationShowing(EFalse);
+TRACES("CStartupAppUi::StopTimingL(): Welcome animation showing stopped");
+if ( iWelcomeAnimation->IsAnimationCancelled())
+{
+TRACES("CStartupAppUi::StopTimingL(): Animation is cancelled by user and therefore operator animation and UWN is not shown");
+StopStartupTone();
+iStartupFirstBootAndRTCCheckAlreadyCalled = ETrue;
+DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+}
+else
+{
+if (iStartupTone->Playing())
+{
+// If tone is still playing wait until it completes.
+iStartupTone->StartupWaiting(ETrue);
+}
+else
+{
+DoNextStartupPhaseL( EStartupWaitingCUIOperatorAnim );
+}
+}
+TRACES("CStartupAppUi::StopTimingL(): Animation stopped");
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 }
 }
 TRACES("CStartupAppUi::StopTimingL(): End");
 }
 iExitTimer->Cancel();
 Exit();
 TRACES("CStartupAppUi::ExitApplication(): End");
 }
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowWelcomeAnimationL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::ShowWelcomeAnimationL()
+{
+TRACES("CStartupAppUi::ShowWelcomeAnimationL()");
+__ASSERT_DEBUG( iWelcomeAnimation , PANIC( EStartupPanicClassMemberVariableIsNull ) );
+TInt showtime = iWelcomeAnimation->ShowingTime();
+iAnimation = ETrue;
+TRACES("CStartupAppUi::ShowWelcomeAnimationL(): Animation timer started");
+iAnimTimer->Start(
+showtime*KOneMilliSecondInMicroSeconds,
+showtime*KOneMilliSecondInMicroSeconds,
+TCallBack( DoStopTimingL, this ) );
+iWelcomeAnimation->StartL();
+TRACES("CStartupAppUi::ShowWelcomeAnimationL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowOperatorAnimationL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::ShowOperatorAnimationL()
+{
+TRACES("CStartupAppUi::ShowOperatorAnimationL()");
+__ASSERT_DEBUG( iOperatorAnimation , PANIC( EStartupPanicClassMemberVariableIsNull ) );
+TInt showtime = iOperatorAnimation->ShowingTime();
+iAnimation = ETrue;
+TRACES("CStartupAppUi::ShowWelcomeAnimationL(): Operator Animation timer started");
+iAnimTimer->Start(
+showtime*KOneMilliSecondInMicroSeconds,
+showtime*KOneMilliSecondInMicroSeconds,
+TCallBack( DoStopTimingL, this ) );
+iOperatorAnimation->StartL();
+TRACES("CStartupAppUi::ShowOperatorAnimationL(): End");
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowUserWelcomeNoteL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::ShowUserWelcomeNoteL()
+{
+TRACES("CStartupAppUi::ShowUserWelcomeNoteL()");
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iUserWelcomeNote = CStartupUserWelcomeNote::NewL( *this, ClientRect(), *iMainView );
+TStartupNoteTypeInformation type = iUserWelcomeNote->NoteTypeInformation();
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+__ASSERT_DEBUG( iUserWelcomeNote , PANIC( EStartupPanicClassMemberVariableIsNull ) );
+TStartupNoteTypeInformation type;
+type = iUserWelcomeNote->NoteTypeInformation();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+if( type == EStartupImage )
+{
+// UserWelcomeNote type is EStartupImage
+// This type of note is shown fixed (KUserWelcomeNoteShowPeriodTime) time
+TRACES("CStartupAppUi::ShowUserWelcomeNoteL(): UWNTimer started (graphic)");
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iAnimation = EFalse;
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+iNoteTimer->Start(
+KUserWelcomeNoteShowPeriodTime,
+KUserWelcomeNoteShowPeriodTime,
+TCallBack( DoStopTimingL, this ) );
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iUserWelcomeNote->StartL();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+}
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
+else if ( type == EStartupText )
+{
+TRACES("CStartupAppUi::ShowUserWelcomeNoteL(): Text UWN");
+iUserWelcomeNote->StartL();
+UpdateStartupUiPhase( EStartupUiPhaseUserWelcomeDone );
+DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+}
+else
+{
+TRACES("CStartupAppUi::ShowUserWelcomeNoteL(): No UWN");
+DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck );
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+else
+{
+//if User Welcome Note type is ETextWelcomeNote nothing to do here,
+//because it is implemented with Avkon globalnote
+//or if type is EDefaultWelcomeNote no User Welcome Note is shown.
+TRACES("CStartupAppUi::ShowUserWelcomeNoteL(): No UWN to show or UWN is text");
+}
+//invoke welcome note container to show note
+iUserWelcomeNote->StartL();
+if( type == EStartupText || type == EStartupNoNote)
+{
+//this is called already here because timer not activated in text uwn case
+//and so DoStopTimingL() is never called and should be called here.
+StopTimingL();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+}
+TRACES("CStartupAppUi::ShowUserWelcomeNoteL(): End");
+}
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::WaitingTouchScreenCalibL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::WaitingTouchScreenCalibL()
+{
+TRACES("CStartupAppUi::WaitingTouchScreenCalibL()");
+#ifdef RD_SCALABLE_UI_V2
+if( iFirstBoot && iTouchScreenCalibSupport )
+{
+if (iTouchScreenCalibrationDone)
+{
+TRACES("CStartupAppUi::WaitingTouchScreenCalibL(): Calibration already done. Continue boot up");
+DoNextStartupPhaseL( EStartupOfflineModeQuery );
+}
+else
+{
+SendToBackground();
+iWelcomeAnimation->UpdateDrawInfo( EStartupDITouchScreenCalib );
+iWelcomeAnimation->DrawNow();
+TRACES("CStartupAppUi::WaitingTouchScreenCalibL(): Startup sequence halted until Touch Screen Calibration is done");
+}
+}
+else
+{
+TRACES("CStartupAppUi::WaitingTouchScreenCalibL(): Not first boot or calibration not supported. Continue boot up");
+DoNextStartupPhaseL( EStartupOfflineModeQuery );
+}
+#else // !RD_SCALABLE_UI_V2
+TRACES("CStartupAppUi::WaitingTouchScreenCalibL(): Calibration not supported. Continue boot up");
+DoNextStartupPhaseL( EStartupOfflineModeQuery );
+#endif // RD_SCALABLE_UI_V2
+TRACES("CStartupAppUi::WaitingTouchScreenCalibL(): End");
+}
+#ifdef RD_SCALABLE_UI_V2
+// ---------------------------------------------------------------------------
+// CStartupAppUi::TouchScreenCalibrationDoneL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::TouchScreenCalibrationDoneL()
+{
+TRACES("CStartupAppUi::TouchScreenCalibrationDoneL()");
+if (iInternalState == EStartupWaitingTouchScreenCalib)
+{
+iTouchScreenCalibrationDone = ETrue;
+BringToForeground();
+DoNextStartupPhaseL( EStartupOfflineModeQuery );
+}
+else
+{
+iTouchScreenCalibrationDone = ETrue;
+}
+TRACES("CStartupAppUi::TouchScreenCalibrationDoneL(): End");
+}
+#endif // RD_SCALABLE_UI_V2
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::CoverUIWelcomeAnimationSyncOKL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::CoverUIWelcomeAnimationSyncOKL()
+{
+TRACES("CStartupAppUi::CoverUIWelcomeAnimationSyncOKL()");
+DoNextStartupPhaseL( EStartupWaitingStartupTone );
+TRACES("CStartupAppUi::CoverUIWelcomeAnimationSyncOKL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::WaitingCoverUIWelcomeAnimationSyncL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::WaitingCoverUIWelcomeAnimationSyncL()
+{
+TRACES("CStartupAppUi::WaitingCoverUIWelcomeAnimationSyncL()");
+if (iCoverUISupported)
+{
+iStartupMediatorObserver->IssueCommand(SecondaryDisplay::ECmdStartupSync,
+SecondaryDisplay::EStartWelcomeAnimation);
+}
+else
+{
+DoNextStartupPhaseL( EStartupWaitingStartupTone );
+}
+TRACES("CStartupAppUi::WaitingCoverUIWelcomeAnimationSyncL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::CoverUIOperatorAnimationSyncOKL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::CoverUIOperatorAnimationSyncOKL()
+{
+TRACES("CStartupAppUi::CoverUIOperatorAnimationSyncOKL()");
+DoNextStartupPhaseL( EStartupShowingOperatorAnimation );
+TRACES("CStartupAppUi::CoverUIOperatorAnimationSyncOKL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::WaitingCoverUIOperatorAnimationSyncL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::WaitingCoverUIOperatorAnimationSyncL()
+{
+TRACES("CStartupAppUi::WaitingCoverUIOperatorAnimationSyncL()");
+if (iCoverUISupported)
+{
+if (iOperatorAnimation->ShowingTime())
+{
+iStartupMediatorObserver->IssueCommand(SecondaryDisplay::ECmdStartupSync,
+SecondaryDisplay::EStartOperatorAnimation );
+}
+else
+{
+DoNextStartupPhaseL( EStartupShowingOperatorAnimation );
+}
+}
+else
+{
+DoNextStartupPhaseL( EStartupShowingOperatorAnimation );
+}
+TRACES("CStartupAppUi::WaitingCoverUIOperatorAnimationSyncL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::WaitingStartupToneL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::WaitingStartupToneL()
+{
+if( iStartupTone->ToneFound() && !iStartupTone->AudioReady() )
+{
+TRACES("CStartupAppUi::WaitingStartupToneL(): Startup tone found but not ready. Waiting tone to init");
+iToneInitTimer = CPeriodic::NewL( EPriorityNormal );
+iToneInitTimer->Start( KOneMilliSecondInMicroSeconds,
+KOneMilliSecondInMicroSeconds,
+TCallBack( ToneInitTimerTimeoutL, this ) );
+}
+else
+{
+TRACES("CStartupAppUi::WaitingStartupToneL(): Audio ready");
+DoNextStartupPhaseL( EStartupShowingWelcomeAnimation );
+}
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ToneInitTimerTimeoutL()
+// ---------------------------------------------------------------------------
+TInt CStartupAppUi::ToneInitTimerTimeoutL(TAny* aObject)
+{
+STATIC_CAST( CStartupAppUi*, aObject )->StartupToneWaitStatusL(); // cast, and call non-static function
+return KErrNone;
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::StartupToneWaitStatusL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::StartupToneWaitStatusL()
+{
+iToneInitWaitTime++;
+TRACES1("CStartupAppUi::StartupToneWaitStatusL(): Total tone init wait time = %d ms", iToneInitWaitTime );
+TBool audioReady = iStartupTone->AudioReady();
+if ( audioReady || (iToneInitWaitTime>=KMaxToneInitWait) )
+{
+iToneInitTimer->Cancel();
+delete iToneInitTimer;
+iToneInitTimer = NULL;
+TRACES1("CStartupAppUi::StartupToneWaitStatusL(): AudioReady: %d, proceed", audioReady );
+DoNextStartupPhaseL( EStartupShowingWelcomeAnimation );
+}
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::CoverUIStartupReadySyncOKL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::CoverUIStartupReadySyncOKL()
+{
+TRACES("CStartupAppUi::CoverUIStartupReadySyncOKL()");
+DoNextStartupPhaseL( EStartupStartupOK );
+TRACES("CStartupAppUi::CoverUIStartupReadySyncOKL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::WaitingCoverUIStartupReadySyncL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::WaitingCoverUIStartupReadySyncL()
+{
+TRACES("CStartupAppUi::WaitingCoverUIStartupReadySyncL()");
+if (iCoverUISupported)
+{
+iStartupMediatorObserver->IssueCommand(SecondaryDisplay::ECmdStartupSync,
+SecondaryDisplay::EStartStartupReady);
+}
+else
+{
+DoNextStartupPhaseL( EStartupStartupOK );
+}
+TRACES("CStartupAppUi::WaitingCoverUIStartupReadySyncL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::RaiseCoverUIEvent()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::RaiseCoverUIEvent( TUid aCategory,
+TInt aEventId,
+const TDesC8& aData )
+{
+TRACES("CStartupAppUi::RaiseCoverUIEvent()");
+if (iCoverUISupported)
+{
+iStartupMediatorObserver->RaiseEvent( aCategory,
+aEventId,
+aData );
+}
+TRACES("CStartupAppUi::RaiseCoverUIEvent(): End");
+}
 // ---------------------------------------------------------------------------
 // CStartupAppUi::SetCriticalBlockEndedL()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::SetCriticalBlockEndedL()
 {
 TRACES("CStartupAppUi::WaitingCriticalBlockEndingL()");
 if( iCriticalBlockEnded )
 {
 TRACES("CStartupAppUi::WaitingCriticalBlockEndingL(): CriticalBlock has ended. Continue.");
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 DoNextStartupPhaseL( EStartupOfflineModeQuery );
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+DoNextStartupPhaseL( EStartupWaitingTouchScreenCalib );
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 }
 TRACES("CStartupAppUi::WaitingCriticalBlockEndingL(): End");
 }
 // ---------------------------------------------------------------------------
 iCriticalBlockEnded = ETrue;
 if ( iInternalState == EStartupWaitingCriticalBlock )
 {
 TRACES("CStartupAppUi::SetEmergencyCallsOnlyL(): Entered emergency calls only state.");
-DoNextStartupPhaseL( EStartupStartupOK );
+DoNextStartupPhaseL( EStartupWaitingCUIStartupReady );
 }
 TRACES("CStartupAppUi::SetEmergencyCallsOnlyL(): End");
 }
 // ---------------------------------------------------------------------------
 DoNextStartupPhaseL( EStartupSystemFatalError );
 }
 TRACES("CStartupAppUi::SwStateFatalStartupErrorL(): End");
 }
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::GetOfflineModeQueryShown()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::GetOfflineModeQueryShown()
+{
+TRACES1("CStartupAppUi::GetOfflineModeQueryShown(): iOfflineModeQueryShown == %d ", iOfflineModeQueryShown );
+return iOfflineModeQueryShown;
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::SetOfflineModeQueryShown()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::SetOfflineModeQueryShown(TBool aValue)
+{
+TRACES1("CStartupAppUi::SetOfflineModeQueryShown(): iOfflineModeQueryShown == %d ", iOfflineModeQueryShown );
+iOfflineModeQueryShown = aValue;
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ----------------------------------------------------------------------------
 // CStartAppUi::DosInOfflineModeL()
 // ----------------------------------------------------------------------------
 TBool CStartupAppUi::DosInOfflineModeL()
 reply = 1;
 }
 else if ( iOfflineModeSupported && DosInOfflineModeL() )
 {
 TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Offline mode query needed");
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 RProperty::Set( KPSUidStartup, KPSSplashShutdown, ESplashShutdown );
 iAnimation->BringToForeground();
 iMainView->DrawDeferred();
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+iWelcomeAnimation->UpdateDrawInfo( EStartupDIQueriesOn );
+iWelcomeAnimation->DrawNow();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 iOfflineModeQueryShown = ETrue;
-CHbDeviceMessageBoxSymbian *aMessageBox = NULL;
+CAknQueryDialog* dlg = new (ELeave) CAknQueryDialog( CAknQueryDialog::ENoTone );
-	aMessageBox = CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EQuestion);
+TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Publish dialog for Secondary UI");
-	 	_LIT(KText, "Continue using phone in Offline mode?");
+dlg->PublishDialogL(SecondaryDisplay::ECmdShowOfflineQuery,
-	aMessageBox->SetTextL(KText);
+SecondaryDisplay::KCatStartup);
-	_LIT(KAcceptText, "Yes");
+if ( dlg->ExecuteLD( R_STARTUP_OFFLINE_MODE_QUERY ) )
-	aMessageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::EAcceptButton, KAcceptText);
-	_LIT(KRejectText, "No");
-	aMessageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::ERejectButton, KRejectText);
-	//aMessageBox->SetDismissPolicy(HbPopup::NoDismiss);
-	//define the selection button to hold user's option choice
-	CHbDeviceMessageBoxSymbian::TButtonId selection;
-	selection = aMessageBox->ExecL();
-if ( selection == CHbDeviceMessageBoxSymbian::EAcceptButton )
 {
 TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Offline Mode query: YES -> Boot to Offline");
 reply = 1;
 }
 else
 if( KErrNone != err )
 {
 TRACES1("CStartupAppUi::ShowOfflineModeQueryL(): KStartupBootIntoOffline set err %d", err);
 }
 TRACES("CStartupAppUi::ShowOfflineModeQueryL(): End");
 }
 // ---------------------------------------------------------------------------
 // CStartupAppUi::CancelAnimation(...)
 // ---------------------------------------------------------------------------
 void CStartupAppUi::CancelAnimation()
 {
 TRACES("CStartupAppUi::CancelAnimation()");
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 iAnimation->Cancel();
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+iWelcomeAnimation->CancelAnimation();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 TRACES("CStartupAppUi::CancelAnimation(): End");
 }
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowCountryAndCityListsL()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::ShowCountryAndCityListsL()
+{
+TRACES("CStartupAppUi::ShowCountryAndCityListsL()");
+TInt cityselected( EFalse );
+while ( !cityselected )
+{
+TRACES1("CStartupAppUi::ShowCountryAndCityListsL(): City item to focus: %d", iCounryListIndex);
+TInt cityGroupId = ShowCountryListL();
+TRACES1("CStartupAppUi::ShowCountryAndCityListsL(): City group id: %d", cityGroupId);
+if ( cityGroupId != KErrCancel )
+{
+cityselected = ShowCityListL(cityGroupId);
+}
+else
+{
+cityselected = ETrue;
+}
+}
+TRACES("CStartupAppUi::ShowCountryAndCityListsL(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowCountryListL()
+// ---------------------------------------------------------------------------
+TInt CStartupAppUi::ShowCountryListL()
+{
+TRACES("CStartupAppUi::ShowCountryListL()");
+CAknSinglePopupMenuStyleListBox* listBox =
+new(ELeave) CAknSinglePopupMenuStyleListBox;
+CleanupStack::PushL(listBox);
+CStartupPopupList* popupList = CStartupPopupList::NewL(listBox, R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT,
+AknPopupLayouts::EMenuGraphicHeadingWindow );
+CleanupStack::PushL(popupList);
+listBox->ConstructL(popupList, EAknListBoxSelectionList | EAknListBoxScrollBarSizeExcluded);
+listBox->CreateScrollBarFrameL( ETrue );
+listBox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
+CEikScrollBarFrame::EAuto );
+listBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );
+CDesCArrayFlat *items = new(ELeave)CDesCArrayFlat(1);
+CleanupStack::PushL(items);
+CTzLocalizer* tzLocalizer = CTzLocalizer::NewL();
+CleanupStack::PushL(tzLocalizer);
+CTzLocalizedCityGroupArray* countryList;
+countryList = tzLocalizer->GetAllCityGroupsL(CTzLocalizer::ETzAlphaNameAscending);
+CleanupStack::PushL(countryList);
+TRACES("CStartupAppUi::ShowCountryListL(): Create list of cities");
+for(TInt i = 0; i <countryList->Count(); i++)
+{
+CTzLocalizedCityGroup& cityGroup = countryList->At(i);
+// Check if the country name is blank.
+// If it is blank, ignore it. Empty name shouldn't be shown in the list.
+if(cityGroup.Name().Compare(KEmpty) != 0)
+{
+TBuf<KMaxCountryLength> countryitem;
+countryitem.Insert(0,cityGroup.Name());
+TRACES1("CStartupAppUi::ShowCountryListL(): Create country to list: %S", &countryitem);
+items->AppendL(countryitem);
+}
+}
+CleanupStack::PopAndDestroy( countryList );
+CTextListBoxModel* model=listBox->Model();
+model->SetItemTextArray(items);
+model->SetOwnershipType(ELbmOwnsItemArray);
+TRACES("CStartupAppUi::ShowCountryListL(): Set title");
+// Set title
+HBufC* title = StringLoader::LoadLC( R_QTN_SU_SELECT_COUNTRY );
+popupList->SetTitleL(title->Des());
+CleanupStack::PopAndDestroy( title );
+popupList->EnableAdaptiveFind();
+listBox->SetCurrentItemIndex(iCounryListIndex);
+TInt cityGroupId;
+if (iCoverUISupported)
+{
+TRACES("CStartupAppUi::ShowCountryListL(): Publish country list for Secondary UI");
+TPckgBuf<TInt> data( SecondaryDisplay::EShowCountryQuery );
+iStartupMediatorObserver->RaiseEvent( SecondaryDisplay::KCatStartup,
+SecondaryDisplay::EMsgStartupEvent,
+data );
+}
+TRACES("CStartupAppUi::ShowCountryListL(): Show the list");
+if (popupList->ExecuteLD())
+{
+iCounryListIndex = listBox->CurrentItemIndex();
+TRACES1("CStartupAppUi::ShowCountryListL(): CurrentItemIndex: %d", iCounryListIndex);
+TPtrC countryName = listBox->Model()->ItemText(iCounryListIndex);
+CTzLocalizedCityGroup* tzLocalizedCityGroup = tzLocalizer->FindCityGroupByNameL(countryName);
+CleanupStack::PushL(tzLocalizedCityGroup);
+cityGroupId = tzLocalizedCityGroup->Id();
+CleanupStack::PopAndDestroy( tzLocalizedCityGroup );
+TRACES1("CStartupAppUi::ShowCountryListL(): Selected country %S", &countryName);
+}
+else
+{
+TRACES("CStartupAppUi::ShowCountryListL(): Country list cancelled");
+cityGroupId = KErrCancel;
+}
+CleanupStack::PopAndDestroy( tzLocalizer );
+CleanupStack::Pop( items );
+CleanupStack::Pop( popupList );
+CleanupStack::PopAndDestroy( listBox );
+TRACES1("CStartupAppUi::ShowCountryListL(): End. Return city group id: %d", cityGroupId);
+return cityGroupId;
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowCityListL()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::ShowCityListL(TUint8 cityGroupId)
+{
+TRACES("CStartupAppUi::ShowCityListL()");
+TBool retval( ETrue );
+CTzLocalizer* tzLocalizer = CTzLocalizer::NewL();
+CleanupStack::PushL(tzLocalizer);
+CTzLocalizedCityArray* cityList;
+TRACES1("CStartupAppUi::ShowCityListL(): Create list of cities in group %d", cityGroupId);
+cityList = tzLocalizer->GetCitiesInGroupL(cityGroupId,//cityGroup.Id(),
+CTzLocalizer::ETzAlphaNameAscending );
+CleanupStack::PushL(cityList);
+if ( cityList->Count() == 1 )
+{
+TRACES("CStartupAppUi::ShowCityListL(): Only one city in citygroup. This can be selected automatically.");
+CTzLocalizedCity& city = cityList->At(0);
+CTzLocalizedCity* tzLocalizedCity = tzLocalizer->FindCityByNameL(city.Name());
+CleanupStack::PushL(tzLocalizedCity);
+TInt timeZoneId = tzLocalizedCity->TimeZoneId();
+tzLocalizer->SetTimeZoneL(timeZoneId);
+tzLocalizer->SetFrequentlyUsedZoneL(*tzLocalizedCity, CTzLocalizedTimeZone::ECurrentZone);
+CleanupStack::PopAndDestroy( tzLocalizedCity );
+CleanupStack::PopAndDestroy( cityList );
+CleanupStack::PopAndDestroy( tzLocalizer );
+TRACES1("CStartupAppUi::ShowCityListL(): End, returns %d", retval);
+return retval;
+}
+CAknSinglePopupMenuStyleListBox* listBox =
+new(ELeave) CAknSinglePopupMenuStyleListBox;
+CleanupStack::PushL(listBox);
+CStartupPopupList* popupList = CStartupPopupList::NewL(listBox, R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT,
+AknPopupLayouts::EMenuGraphicHeadingWindow );
+CleanupStack::PushL(popupList);
+CDesCArrayFlat *items = new(ELeave)CDesCArrayFlat(1);
+CleanupStack::PushL(items);
+for(TInt j = 0; j < cityList->Count(); j++)
+{
+CTzLocalizedCity& city = cityList->At(j);
+// Check if the city name is blank.
+// If it is blank, ignore it. Empty name shouldn't be shown in the list.
+if(city.Name().Compare(KEmpty) != 0)
+{
+TBuf<KMaxCityLength> homecityitem;
+homecityitem.Insert(0,city.Name());
+TRACES1("CStartupAppUi::ShowCityListL(): Create to list: %S", &homecityitem);
+items->AppendL(homecityitem);
+}
+}
+listBox->ConstructL(popupList, EAknListBoxSelectionList | EAknListBoxScrollBarSizeExcluded);
+listBox->CreateScrollBarFrameL( ETrue );
+listBox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,
+CEikScrollBarFrame::EAuto );
+listBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue );
+CTextListBoxModel* model=listBox->Model();
+model->SetItemTextArray(items);
+model->SetOwnershipType(ELbmOwnsItemArray);
+TRACES("CStartupAppUi::ShowCityListL(): Set title");
+// Set title
+HBufC* title = StringLoader::LoadLC( R_QTN_SU_SELECT_CITY );
+popupList->SetTitleL(title->Des());
+CleanupStack::PopAndDestroy(title);
+popupList->EnableAdaptiveFind();
+if (iCoverUISupported)
+{
+TRACES("CStartupAppUi::ShowCountryListL(): Publish city list for Secondary UI");
+TPckgBuf<TInt> data( SecondaryDisplay::EShowCityQuery );
+iStartupMediatorObserver->RaiseEvent( SecondaryDisplay::KCatStartup,
+SecondaryDisplay::EMsgStartupEvent,
+data );
+}
+TRACES("CStartupAppUi::ShowCityListL(): Show the list");
+if (popupList->ExecuteLD())
+{
+TInt index(listBox->CurrentItemIndex());
+TRACES1("CStartupAppUi::ShowCityListL(): CurrentItemIndex: %d", index);
+TPtrC cityName = listBox->Model()->ItemText(index);
+CTzLocalizedCity* tzLocalizedCity = tzLocalizer->FindCityByNameL(cityName);
+CleanupStack::PushL(tzLocalizedCity);
+TInt timeZoneId = tzLocalizedCity->TimeZoneId();
+tzLocalizer->SetTimeZoneL(timeZoneId);
+tzLocalizer->SetFrequentlyUsedZoneL(*tzLocalizedCity, CTzLocalizedTimeZone::ECurrentZone);
+CleanupStack::PopAndDestroy(tzLocalizedCity);
+TRACES1("CStartupAppUi::ShowCityListL(): Selected city    %S", &cityName);
+}
+else
+{
+TRACES("CStartupAppUi::ShowCityListL(): City list cancelled");
+retval = EFalse;
+}
+CleanupStack::Pop(items);
+CleanupStack::Pop(popupList);
+CleanupStack::PopAndDestroy(listBox);
+CleanupStack::PopAndDestroy(cityList);
+CleanupStack::PopAndDestroy(tzLocalizer);
+TRACES("CStartupAppUi::ShowCityListL(): Home city selected");
+TRACES1("CStartupAppUi::ShowCityListL(): End, return %d", retval);
+return retval;
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowTimeQueryL()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::ShowTimeQueryL()
+{
+TRACES("CStartupAppUi::ShowTimeQueryL()");
+TTime time;
+GetDefaultTimeAndDate( time );
+CStartupQueryDialog* dlg = new (ELeave) CStartupQueryDialog(time, CAknQueryDialog::ENoTone);
+TRACES("CStartupAppUi::ShowTimeQueryL(): Publish dialog for Secondary UI");
+dlg->PublishDialogL(SecondaryDisplay::ECmdShowTimeQuery, SecondaryDisplay::KCatStartup);
+if( dlg->ExecuteLD( R_STARTUP_TIME_SETTING_QUERY ) )
+{
+TTime current;
+current.HomeTime();
+TDateTime cTime = current.DateTime();
+TDateTime atime = time.DateTime();
+atime.SetYear(cTime.Year());
+atime.SetMonth(cTime.Month());
+atime.SetDay(cTime.Day());
+time = atime;
+RTz rtz;
+User::LeaveIfError(rtz.Connect());
+User::LeaveIfError(rtz.SetHomeTime(time));
+rtz.Close();
+TRACES("CStartupAppUi::ShowTimeQueryL(): End, return ETrue");
+return ETrue;
+}
+else
+{
+//in case of poweroff key was pressed and shutdown is occuring
+TRACES("CStartupAppUi::ShowTimeQueryL(): End, return EFalse");
+return EFalse;
+}
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::ShowDateQueryL()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::ShowDateQueryL()
+{
+TRACES("CStartupAppUi::ShowDateQueryL()");
+CStartupQueryDialog* dlg = new (ELeave) CStartupQueryDialog(iTime, CAknQueryDialog::ENoTone);
+TRACES("CStartupAppUi::ShowDateQueryL(): Publish dialog for Secondary UI");
+dlg->PublishDialogL(SecondaryDisplay::ECmdShowDateQuery, SecondaryDisplay::KCatStartup);
+TInt query( R_STARTUP_DATE_SETTING_QUERY_NOBACK );
+if ( iFirstBoot )
+{
+query = R_STARTUP_DATE_SETTING_QUERY;
+}
+if( dlg->ExecuteLD( query ) )
+{
+TTime current;
+current.HomeTime();
+TDateTime cTime = current.DateTime();
+TDateTime atime = iTime.DateTime();
+atime.SetHour(cTime.Hour());
+atime.SetMinute(cTime.Minute());
+atime.SetSecond(cTime.Second());
+atime.SetMicroSecond(cTime.MicroSecond());
+iTime = atime;
+RTz rtz;
+User::LeaveIfError(rtz.Connect());
+User::LeaveIfError(rtz.SetHomeTime(iTime));
+rtz.Close();
+TRACES("CStartupAppUi::ShowDateQueryL(): End, return ETrue");
+return ETrue;
+}
+else
+{
+// Back key pressed. ( Or poweroff key was pressed and shutdown is occuring )
+TRACES("CStartupAppUi::ShowDateQueryL(): End, return EFalse");
+return EFalse;
+}
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::GetDefaultTimeAndDate()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::GetDefaultTimeAndDate( TTime& aTime )
+{
+TRACES("CStartupAppUi::GetDefaultTimeAndDate(): Get Time and Date from CenRep");
+CRepository* repository(NULL);
+TRAPD( err, repository = CRepository::NewL( KCRUidStartupConf ) );
+if ( !err )
+{
+TBuf<KTimeFormatLength> buf;
+err = repository->Get( KStartupDefaultTime, buf );
+if( !err )
+{
+err = aTime.Set(buf); // returns error if cenrep time format not valid
+}
+}
+if ( err )
+{
+TRACES("CStartupAppUi::GetDefaultTimeAndDate(): Failed to get valid data from CenRep. Using default");
+aTime.Set(KDefaultDateTimeValue);
+}
+delete repository;
+TRACES("CStartupAppUi::GetDefaultTimeAndDate(): End");
+}
 // ---------------------------------------------------------------------------
 // CStartupAppUi::FirstBoot()
 // ---------------------------------------------------------------------------
 TBool CStartupAppUi::FirstBoot()
 delete repository;
 TRACES("CStartupAppUi::MarkFirstBoot(): End");
 }
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ---------------------------------------------------------------------------
 // CStartupAppUi::AnimationFinished()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::AnimationFinished()
 {
 {
 TRAP(err, DoNextStartupPhaseL( EStartupShowingOperatorAnimation ));
 }
 else if ( iInternalState == EStartupShowingOperatorAnimation )
 {
-TRAP(err, DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck));
+TRAP(err, DoNextStartupPhaseL( EStartupShowingUserWelcomeNote ));
 }
 if ( err != KErrNone )
 {
 TRAP_IGNORE( DoNextStartupPhaseL(EStartupSystemFatalError) );
 }
 TRACES("CStartupAppUi::AnimationFinished(): End");
 }
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+// ---------------------------------------------------------------------------
+// CStartupAppUi::StopStartupTone()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::StopStartupTone()
+{
+TRACES("CStartupAppUi::StopStartupTone()");
+if ((iStartupTone) && (iStartupTone->Playing()))
+{
+iStartupTone->Stop();
+}
+TRACES("CStartupAppUi::StopStartupTone(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::StopOperatorTone()
+// ---------------------------------------------------------------------------
+void CStartupAppUi::StopOperatorTone()
+{
+TRACES("CStartupAppUi::StopOperatorTone()");
+if ((iOpStartupTone) && (iOpStartupTone->Playing()))
+{
+iOpStartupTone->Stop();
+}
+TRACES("CStartupAppUi::StopOperatorTone(): End");
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::StartupTonePlaying()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::StartupTonePlaying()
+{
+TRACES("CStartupAppUi::StartupTonePlaying()");
+return iStartupTone->Playing();
+}
+// ---------------------------------------------------------------------------
+// CStartupAppUi::OperatorTonePlaying()
+// ---------------------------------------------------------------------------
+TBool CStartupAppUi::OperatorTonePlaying()
+{
+TRACES("CStartupAppUi::OperatorTonePlaying()");
+return iOpStartupTone->Playing();
+}
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ---------------------------------------------------------------------------
 // CStartupAppUi::SetCleanBoot()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::SetCleanBoot()
 {
 TRACES("CStartupAppUi::SimSupported()");
 return iSimSupported;
 }
+// ----------------------------------------------------------------------------
+// CStartupAppUi::CoverUISupported()
+// ----------------------------------------------------------------------------
+TBool CStartupAppUi::CoverUISupported()
+{
+TRACES("CStartupAppUi::CoverUISupported()");
+return iCoverUISupported;
+}
 // ---------------------------------------------------------------------------
 // CStartupAppUi::DoNextStartupPhaseL( TStartupInternalState toState )
 // State#                                Possible next states
 // 0    EStartupStartingUp               1, 18
 // 1    EStartupWaitingCriticalBlock     5, 18
 // 5    EStartupWaitingTouchScreenCalib
 // 6    EStartupWaitingPhoneLightIdle    8, 18
 // 8    EStartupOfflineModeQuery         9, 18
-// 9    EStartupWaitingCUIWelcomeAnim    10, 18 Removed
+// 9    EStartupWaitingCUIWelcomeAnim    10, 18
 // 10   EStartupWaitingStartupTone       11, 18
 // 11   EStartupShowingWelcomeAnimation  12, 14, 18
 // 12   EStartupWaitingCUIOperatorAnim   13, 18
 // 13   EStartupShowingOperatorAnimation 14, 14, 18
-// 14   EStartupShowingUserWelcomeNote   15, 18 Removed
+// 14   EStartupShowingUserWelcomeNote   15, 18
 // 15   EStartupFirstBootAndRTCCheck     16, 18
-// 16   EStartupWaitingCUIStartupReady   17, 18 Removed
+// 16   EStartupWaitingCUIStartupReady   17, 18
 // 17   EStartupStartupOK                -
 // 18   EStartupSystemFatalError         -
 // ---------------------------------------------------------------------------
 break;
 case EStartupWaitingCriticalBlock:
 {
 switch( toState )
 {
-case EStartupStartupOK:
+case EStartupWaitingCUIStartupReady:
-iInternalState = EStartupStartupOK;
+iInternalState = EStartupWaitingCUIStartupReady;
-TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupStartupOK");
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingCUIStartupReady");
-DoStartupEndPart();
+WaitingCoverUIStartupReadySyncL();
 break;
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupWaitingTouchScreenCalib:
+iInternalState = EStartupWaitingTouchScreenCalib;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingTouchScreenCalib");
+WaitingTouchScreenCalibL();
+break;
+case EStartupSystemFatalError:
+SystemFatalErrorL();
+break;
+default:
+__ASSERT_DEBUG(
+EFalse,
+PANIC( EStartupInvalidInternalStateChange ) );
+break;
+}
+}
+break;
+case EStartupWaitingTouchScreenCalib:
+{
+switch( toState )
+{
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 case EStartupOfflineModeQuery:
 iInternalState = EStartupOfflineModeQuery;
 TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupOfflineModeQuery");
 ShowOfflineModeQueryL();
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 DoNextStartupPhaseL( EStartupWaitingShowStartupAnimation );
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+DoNextStartupPhaseL( EStartupWaitingCUIWelcomeAnim );
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 break;
 case EStartupSystemFatalError:
 SystemFatalErrorL();
 break;
 default:
 break;
 case EStartupOfflineModeQuery:
 {
 switch( toState )
 {
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 case EStartupWaitingShowStartupAnimation:
 iInternalState = EStartupWaitingShowStartupAnimation;
 TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingShowStartupAnimation");
 WaitingStartupAnimationStartL();
 break;
-case EStartupSystemFatalError:
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupWaitingCUIWelcomeAnim:
+iInternalState = EStartupWaitingCUIWelcomeAnim;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingCUIWelcomeAnim");
+WaitingCoverUIWelcomeAnimationSyncL();
+break;
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupSystemFatalError:
 SystemFatalErrorL();
 break;
 default:
 __ASSERT_DEBUG(
 EFalse,
 PANIC( EStartupInvalidInternalStateChange ) );
 break;
 }
 }
 break;
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupWaitingCUIWelcomeAnim:
+{
+switch( toState )
+{
+case EStartupWaitingStartupTone:
+iInternalState = EStartupWaitingStartupTone;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingStartupTone");
+WaitingStartupToneL();
+break;
+case EStartupSystemFatalError:
+SystemFatalErrorL();
+break;
+default:
+__ASSERT_DEBUG( EFalse,
+PANIC( EStartupInvalidInternalStateChange ) );
+break;
+}
+}
+break;
+case EStartupWaitingStartupTone:
+{
+switch( toState )
+{
+case EStartupShowingWelcomeAnimation:
+iInternalState = EStartupShowingWelcomeAnimation;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupShowingWelcomeAnimation");
+iWelcomeAnimation->UpdateDrawInfo( EStartupDIWelcomeAnimStart );
+iWelcomeAnimation->DrawNow();
+DoStartupShowWelcomeAnimationL();
+iWelcomeAnimation->UpdateDrawInfo( EStartupDIWelcomeAnimEnd );
+iWelcomeAnimation->DrawNow();
+break;
+case EStartupSystemFatalError:
+SystemFatalErrorL();
+break;
+default:
+__ASSERT_DEBUG( EFalse,
+PANIC( EStartupInvalidInternalStateChange ) );
+break;
+}
+}
+break;
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 case EStartupWaitingShowStartupAnimation:
 {
 switch( toState )
 {
 case EStartupShowingWelcomeAnimation:
 break;
 case EStartupShowingWelcomeAnimation:
 {
 switch( toState )
 {
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 case EStartupShowingOperatorAnimation:
 iInternalState = EStartupShowingOperatorAnimation;
 TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState: EStartupShowingOperatorAnimation");
 DoStartupShowOperatorAnimationL();
+#else // RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupWaitingCUIOperatorAnim:
+iOperatorAnimation = CStartupOperatorAnimation::NewL( this, ClientRect());
+AddToStackL( iOperatorAnimation);
+iInternalState = EStartupWaitingCUIOperatorAnim;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState: EStartupWaitingCUIOperatorAnim");
+WaitingCoverUIOperatorAnimationSyncL();
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 break;
 case EStartupFirstBootAndRTCCheck:
 iInternalState = EStartupFirstBootAndRTCCheck;
 TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupFirstBootAndRTCCheck");
 DoStartupFirstBootAndRTCCheckL();
 PANIC( EStartupInvalidInternalStateChange ) );
 break;
 }
 }
 break;
-case EStartupShowingOperatorAnimation:
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupWaitingCUIOperatorAnim:
 {
 switch( toState )
 {
+case EStartupShowingOperatorAnimation:
+iInternalState = EStartupShowingOperatorAnimation;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState: EStartupShowingOperatorAnimation");
+iOperatorAnimation->UpdateDrawInfo( EStartupDIOperatorAnimStart );
+DoStartupShowOperatorAnimationL();
+break;
+case EStartupSystemFatalError:
+SystemFatalErrorL();
+break;
+default:
+__ASSERT_DEBUG( EFalse,
+PANIC( EStartupInvalidInternalStateChange ) );
+break;
+}
+}
+break;
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+case EStartupShowingOperatorAnimation:
+{
+switch( toState )
+{
+case EStartupShowingUserWelcomeNote:
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iUserWelcomeNote = CStartupUserWelcomeNote::NewL( *this, ClientRect());
+AddToStackL( iUserWelcomeNote );
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+iInternalState = EStartupShowingUserWelcomeNote;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState: EStartupShowingUserWelcomeNote");
+#ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION
+iWelcomeAnimation->UpdateDrawInfo( EStartupDIWelcomeNoteStart );
+iUserWelcomeNote->SetUserWelcomeNoteShowing(ETrue);
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
+DoStartupShowUserWelcomeNoteL();
+break;
 case EStartupFirstBootAndRTCCheck:
 iInternalState = EStartupFirstBootAndRTCCheck;
 TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupFirstBootAndRTCCheck");
 DoStartupFirstBootAndRTCCheckL();
 break;
 PANIC( EStartupInvalidInternalStateChange ) );
 break;
 }
 }
 break;
+case EStartupShowingUserWelcomeNote:
+{
+switch( toState )
+{
+case EStartupFirstBootAndRTCCheck:
+iInternalState = EStartupFirstBootAndRTCCheck;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupFirstBootAndRTCCheck");
+DoStartupFirstBootAndRTCCheckL();
+break;
+case EStartupSystemFatalError:
+SystemFatalErrorL();
+break;
+default:
+__ASSERT_DEBUG( EFalse,
+PANIC( EStartupInvalidInternalStateChange ) );
+break;
+}
+}
+break;
 case EStartupFirstBootAndRTCCheck:
+{
+switch( toState )
+{
+case EStartupWaitingCUIStartupReady:
+iInternalState = EStartupWaitingCUIStartupReady;
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingCUIStartupReady");
+WaitingCoverUIStartupReadySyncL();
+break;
+case EStartupSystemFatalError:
+SystemFatalErrorL();
+break;
+default:
+__ASSERT_DEBUG( EFalse,
+PANIC( EStartupInvalidInternalStateChange ) );
+break;
+}
+}
+break;
+case EStartupWaitingCUIStartupReady:
 {
 switch( toState )
 {
 case EStartupStartupOK:
 iInternalState = EStartupStartupOK;
-TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupInvokeAndWaitForFtu");
+TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupStartupOK");
 DoStartupEndPart();
 break;
 case EStartupSystemFatalError:
 SystemFatalErrorL();
 break;
 default:
 {
 case EStartupStartingUp:
 case EStartupOfflineModeQuery:
 case EStartupShowingWelcomeAnimation:
 case EStartupShowingOperatorAnimation:
+case EStartupShowingUserWelcomeNote:
 case EStartupFirstBootAndRTCCheck:
 case EStartupWaitingCUIStartupReady:
 case EStartupStartupOK:
 case EStartupSystemFatalError:
 //no need to continue, because state is
 }
 TRACES1( "CStartupAppUi::SimStatusChangedReset(): End, return %d", ret_val );
 return ret_val;
 }
+#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION
 // ---------------------------------------------------------------------------
 // CStartupAppUi::UpdateStartupUiPhase()
 // ---------------------------------------------------------------------------
 void CStartupAppUi::UpdateStartupUiPhase( TInt aValue )
 {
 if( KErrNone != err )
 {
 TRACES1("CStartupAppUi::UpdateStartupUiPhase(): KPSStartupUiPhase set err %d", err);
 }
 }
+#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION
 // End of file

branch	RCL_3
changeset 20	c2c61fdca848
parent 19	924385140d98