diff -r 000000000000 -r 2e3d3ce01487 startupservices/Startup/src/StartupAppUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/startupservices/Startup/src/StartupAppUi.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,2734 @@ +/* +* 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". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: AppUi class of the application. +* +*/ + + +// SYSTEM INCLUDES +#include +#include //used for Selftest failed note +#include +#include +#include +#include +#include +#include +#include +#include // Feature Manager +#include +#include +#include +#include "startupappprivatepskeys.h" +#include +#include +#include +#include + +#ifdef RD_UI_TRANSITION_EFFECTS_PHASE2 +// Transition effects +#include +#include +#endif + +#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION + #include "sanimstartupctrl.h" +#else // RD_STARTUP_ANIMATION_CUSTOMIZATION + #include // For layout change event definitions + #include +#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( 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"); + + CancelAnimation(); + response = EKeyWasConsumed; + } + } + + TRACES1("CStartupAppUi::HandleKeyEventL(): End, return %d", response); + return response; + } + +#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION +// --------------------------------------------------------------------------- +// CStartupAppUi::HandleResourceChangeL +// +// --------------------------------------------------------------------------- +// +void CStartupAppUi::HandleResourceChangeL( TInt aType ) + { + TRACES("CStartupAppUi::HandleResourceChangeL()"); + TRACES1("CStartupAppUi::HandleResourceChangeL Type: %d", aType); + + CAknAppUi::HandleResourceChangeL( aType ); + + if ( aType == KEikDynamicLayoutVariantSwitch ) + { + iMainView->SetRect( ApplicationRect() ); + } + + TRACES("CStartupAppUi::HandleResourceChangeL(): End"); + } +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION + + +// --------------------------------------------------------------------------- +// CStartupAppUi::HandleCommandL(TInt aCommand) +// --------------------------------------------------------------------------- +void CStartupAppUi::HandleCommandL(TInt aCommand) + { + TRACES("CStartupAppUi::HandleCommandL()"); + switch (aCommand) + { + case EEikCmdExit: + { + TRACES("CStartupAppUi::HandleCommandL(): EEikCmdExit"); + Exit(); + } + break; + default: + break; + }//End of switch-clause + TRACES("CStartupAppUi::HandleCommandL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::DoStartupStartPartL() +// --------------------------------------------------------------------------- +void CStartupAppUi::DoStartupStartPartL() + { + TRACES("CStartupAppUi::DoStartupStartPartL()"); +#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() + { + TRACES("CStartupAppUi::TryPreLoadAnimation()"); + + TInt state( ESwStateStartingCriticalApps ); + TInt err; + err = RProperty::Get( KPSUidStartup, KPSGlobalSystemState, state ); // Use default if this fails + if( KErrNone != err ) + { + TRACES1("CStartupAppUi::TryPreLoadAnimation(): KPSGlobalSystemState get err %d", err); + } + TInt mode( EStartupModeNormal ); + err = RProperty::Get( KPSUidStartup, KPSGlobalStartupMode, mode ); // Use default if this fails + if( KErrNone != err ) + { + TRACES1("CStartupAppUi::TryPreLoadAnimation(): KPSGlobalStartupMode get err %d", err); + } + + TRACES2("CStartupAppUi::TryPreLoadAnimation(): State: %d, mode %d", state, mode); + + if ( ( !HiddenReset() || iFirstBoot ) && // First boot or not-a-reset + ( ( ( state == ESwStateStartingCriticalApps || state == ESwStateSelfTestOK ) && + mode == EStartupModeNormal ) || // Not going to charging or alarm mode + state == ESwStateSecurityCheck ) ) + { + iAnimation->PreLoad( + ClientRect(), + *iMainView, + KStartupAnimationParams, + ETrue, + SecondaryDisplay::EStartWelcomeAnimation ); + } + + TRACES("CStartupAppUi::TryPreLoadAnimation(): End"); + } +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION + + +// --------------------------------------------------------------------------- +// CStartupAppUi::DoStartupShowWelcomeAnimationL() +// --------------------------------------------------------------------------- +void CStartupAppUi::DoStartupShowWelcomeAnimationL() + { + TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL()"); + if ( HiddenReset() ) + { + //skip the welcome animation and user welcome note and continue with + //the same way like in the end of ShowUserWelcomeNoteL() + TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): Skip the animation and UWN because it's hidden reset"); + TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): and change internal state directly to EStartupFirstBootAndRTCCheck"); +#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, + 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(iEikonEnv-> + EikAppUi())-> + KeySounds()-> + PlaySound( EAvkonSIDPowerOnTone ); + } + iWelcomeAnimation->SetAnimationShowing(ETrue); + ShowWelcomeAnimationL(); +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION + + TRACES("CStartupAppUi::DoStartupShowWelcomeAnimationL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::DoStartupShowOperatorAnimationL() +// --------------------------------------------------------------------------- +void CStartupAppUi::DoStartupShowOperatorAnimationL() + { + TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL()"); + if ( HiddenReset() ) + { + //skip the operator animation and user welcome note and continue with + //the same way like in the end of ShowUserWelcomeNoteL() + TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): Skip the animation and UWN because it's hidden reset"); + TRACES("CStartupAppUi::DoStartupShowOperatorAnimationL(): and change internal state directly to EStartupFirstBootAndRTCCheck"); + DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck ); +#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.iRepositoryUid = KCRUidStartupConf; + params.iAnimationPathKey = KStartupOperatorAnimationPath; + params.iFrameDelayKey = KStartupOperatorAnimationFrameDelay; + params.iEnableScalingKey = KStartupOperatorAnimationScaling; + params.iTonePathKey = KStartupOperatorTonePath; + params.iVolumeKey = KStartupOperatorToneVolume; + iAnimation->Play( + ClientRect(), + *iMainView, + params, + EFalse, + SecondaryDisplay::EStartOperatorAnimation, + TCallBack( AnimationFinishedFunc, this ) ); + } +#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() + { + TRACES("CStartupAppUi::PredictiveTimeEnabled()"); + + TInt value( EPredictiveTimeEnabled ); + CRepository* repository(NULL); + + TRAPD( err, repository = CRepository::NewL( KCRUidStartupConf ) ); + if ( err == KErrNone ) + { + err = repository->Get( KPredictiveTimeAndCountrySelection, value ); + } + delete repository; + + TRACES1("CStartupAppUi::PredictiveTimeEnabled(): returns %d", value); + return value; + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::DoStartupFirstBootAndRTCCheckL() +// --------------------------------------------------------------------------- +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() ) + { + TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): First boot. Show city, time and date queries."); + + +#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()) + { + TRACES("CStartupAppUi::DoStartupFirstBootAndRTCCheckL(): No first boot but RTCStatus is corrupted. Ask time and date"); + #ifndef RD_STARTUP_ANIMATION_CUSTOMIZATION + 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(); + } + } + + 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( 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 + UpdateStartupUiPhase( EStartupUiPhaseAllDone ); +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION + + TRACES("CStartupAppUi::DoStartupEndPart(): Exit application."); + iExitTimer->Start( 100000, 100000, TCallBack( DoExitApplication, this ) ); + TRACES("CStartupAppUi::DoStartupEndPart(): DoExitApplication-timer called."); + TRACES("CStartupAppUi::DoStartupEndPart(): End"); + } + +#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() + { + TRACES("CStartupAppUi::StopTimingL()"); + if( !iStartupFirstBootAndRTCCheckAlreadyCalled ) + { + if (iInternalState == EStartupShowingUserWelcomeNote) + { + //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"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::ExitApplication() +// --------------------------------------------------------------------------- +void CStartupAppUi::ExitApplication() + { + TRACES("CStartupAppUi::ExitApplication()"); + 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::SetCriticalBlockEndedL()"); + iCriticalBlockEnded = ETrue; + if ( iInternalState == EStartupWaitingCriticalBlock ) + { + WaitingCriticalBlockEndingL(); + } + TRACES("CStartupAppUi::SetCriticalBlockEndedL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::WaitingCriticalBlockEndingL() +// --------------------------------------------------------------------------- +void CStartupAppUi::WaitingCriticalBlockEndingL() + { + 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"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::SetWaitingStartupAnimationStartL() +// --------------------------------------------------------------------------- +void CStartupAppUi::SetWaitingStartupAnimationStartL() + { + TRACES("CStartupAppUi::SetWaitingStartupAnimationStartL()"); + iStartupWaitingShowStartupAnimation = ETrue; + if ( iInternalState == EStartupWaitingShowStartupAnimation ) + { + WaitingStartupAnimationStartL(); + } + TRACES("CStartupAppUi::SetWaitingStartupAnimationStartL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::WaitingStartupAnimationStartL() +// --------------------------------------------------------------------------- +void CStartupAppUi::WaitingStartupAnimationStartL() + { + TRACES("CStartupAppUi::WaitingStartupAnimationStartL()"); + + if( iStartupWaitingShowStartupAnimation ) + { + TRACES("CStartupAppUi::WaitingStartupAnimationStartL(): Continue."); + DoNextStartupPhaseL( EStartupShowingWelcomeAnimation ); + } + TRACES("CStartupAppUi::WaitingStartupAnimationStartL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::SetEmergencyCallsOnlyL() +// --------------------------------------------------------------------------- +void CStartupAppUi::SetEmergencyCallsOnlyL() + { + TRACES("CStartupAppUi::SetEmergencyCallsOnlyL()"); + iCriticalBlockEnded = ETrue; + if ( iInternalState == EStartupWaitingCriticalBlock ) + { + TRACES("CStartupAppUi::SetEmergencyCallsOnlyL(): Entered emergency calls only state."); + + DoNextStartupPhaseL( EStartupWaitingCUIStartupReady ); + } + TRACES("CStartupAppUi::SetEmergencyCallsOnlyL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::SwStateFatalStartupErrorL() +// --------------------------------------------------------------------------- +void CStartupAppUi::SwStateFatalStartupErrorL(TBool aPropertyChanged) + { + TRACES("CStartupAppUi::SwStateFatalStartupErrorL()"); + + iSwStateFatalStartupError = ETrue; + + if ( aPropertyChanged ) + { + TRACES("CStartupAppUi::SwStateFatalStartupErrorL(): property changed"); + 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() + { + TRACES("CStartupAppUi::DosInOfflineModeL()"); + if ( iOfflineModeSupported ) + { + TRACES1("CStartupAppUi::DosInOfflineModeL(): iOfflineModeSupported == %d", iOfflineModeSupported ); + return UiInOfflineMode(); + } + else + { + TRACES("CStartupAppUi::DosInOfflineModeL(): return EFalse"); + return EFalse; // device that does not support Off-line Mode can never be in Off-line Mode. + } + } + + +// ---------------------------------------------------------------------------- +// CStartupAppUi::UiInOfflineMode() +// ---------------------------------------------------------------------------- + +TBool CStartupAppUi::UiInOfflineMode() + { + TRACES("CStartupAppUi::UiInOfflineMode()"); + if ( iOfflineModeSupported ) + { + TInt networkConnectionAllowed ( 0 ); + + TRACES("CStartupAppUi::UiInOfflineMode(): Check Offline status from CenRep"); + CRepository* repository(NULL); + + TRAPD( err, repository = CRepository::NewL( KCRUidCoreApplicationUIs ) ); + if ( err == KErrNone ) + { + err = repository->Get( KCoreAppUIsNetworkConnectionAllowed, networkConnectionAllowed ); + } + + #ifdef _DEBUG + if ( err != KErrNone ) + TRACES1("CStartupAppUi::UiInOfflineMode(): Central repository access failed, error code %d.", err ); + else + TRACES1("CStartupAppUi::UiInOfflineMode(): Offline: network connection allowed: %d", networkConnectionAllowed); + #endif + delete repository; + + TRACES1("CStartupAppUi::UiInOfflineMode(): returns %d", !( TBool ) networkConnectionAllowed); + + return ( ! ( TBool ) networkConnectionAllowed ); + } + else + { + TRACES("CStartupAppUi::UiInOfflineMode(): DosInOfflineMode returns EFalse"); + return EFalse; // device that does not support Off-line Mode can never be in Off-line Mode. + } + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::ShowOfflineModeQueryL() +// --------------------------------------------------------------------------- +void CStartupAppUi::ShowOfflineModeQueryL() + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL()"); + + TInt status( EStartupSimInitWait ); + RProperty::Get(KPSUidStartup, KPSSimStatus, status); + + TInt reply ( 0 ); + if (status == ESimUsable || status == ESimReadable || status == ESimNotReady || !iSimSupported) + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Show offline mode query if needed"); + + if ( HiddenReset() && DosInOfflineModeL() && !SimStatusChangedReset() ) + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Offline Mode: Hidden reset and DOS in offline mode -> Boot to Offline"); + 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; + CAknQueryDialog* dlg = new (ELeave) CAknQueryDialog( CAknQueryDialog::ENoTone ); + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Publish dialog for Secondary UI"); + dlg->PublishDialogL(SecondaryDisplay::ECmdShowOfflineQuery, + SecondaryDisplay::KCatStartup); + if ( dlg->ExecuteLD( R_STARTUP_OFFLINE_MODE_QUERY ) ) + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Offline Mode query: YES -> Boot to Offline"); + reply = 1; + } + else + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Offline Mode query: NO -> Boot to Online"); + reply = 0; + } + } + else + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): Offline Mode: DOS in online mode -> Boot to Online"); + reply = 0; + } + + } +#ifdef _DEBUG + else + { + TRACES("CStartupAppUi::ShowOfflineModeQueryL(): SIM card removed. No offline mode query."); + } +#endif + + TRACES1("CStartupAppUi::ShowOfflineModeQueryL(): BootIntoOffline=%d.", reply); + TInt err = RProperty::Set( KPSUidStartup, + KStartupBootIntoOffline, + reply ? EBootIntoOfflineMode : EBootIntoOnlineMode ); + + 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 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 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 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 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 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 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() + { + TRACES("CStartupAppUi::FirstBoot()"); + TInt value( 0 ); + + TRACES("CStartupAppUi::FirstBoot(): Read first boot info from Central Repository "); + CRepository* repository(NULL); + + TRAPD( err, repository = CRepository::NewL( KCRUidStartup ) ); + if ( err == KErrNone ) + { + err = repository->Get( KStartupFirstBoot, value ); + } + + delete repository; + + if (value) + { + TRACES("CStartupAppUi::FirstBoot(): End, return EFalse"); + return EFalse; + } + + else + { + TRACES("CStartupAppUi::FirstBoot(): End, return ETrue"); + return ETrue; + } + } +// --------------------------------------------------------------------------- +// CStartupAppUi::HiddenReset() +// --------------------------------------------------------------------------- +TBool CStartupAppUi::HiddenReset() + { + TRACES("CStartupAppUi::HiddenReset()"); + + TBool ret_val ( EFalse ); + if( !iFirstBoot ) + { + TInt startupReason( ENormalStartup ); + TInt err = RProperty::Get( KPSUidStartup, + KPSStartupReason, + startupReason ); // Use default if this fails + if( KErrNone != err ) + { + TRACES1("CStartupAppUi::HiddenReset(): ENormalStartup get err %d", err); + } + ret_val = ( startupReason != ENormalStartup ); + } + TRACES1("CStartupAppUi::HiddenReset(): End, return %d ",ret_val ); + return ret_val; + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::RTCStatus() +// --------------------------------------------------------------------------- +TBool CStartupAppUi::RTCStatus() + { + TRACES("CStartupAppUi::RTCStatus()"); + TBool ret_val ( EFalse ); + + RStarterSession startersession; + if( startersession.Connect() == KErrNone ) + { + TRACES("CStartupAppUi::RTCStatus(): Connected to Starter "); + ret_val = startersession.IsRTCTimeValid(); + startersession.Close(); + } + else + { + TRACES("CStartupAppUi::RTCStatus(): Unable to connect to Starter "); + } + + TRACES1("CStartupAppUi::RTCStatus(): End, return %d ",ret_val ); + return ret_val; + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::MarkFirstBoot() +// --------------------------------------------------------------------------- +void CStartupAppUi::MarkFirstBoot() + { + TRACES("CStartupAppUi::MarkFirstBoot()"); + TRACES("CStartupAppUi::MarkFirstBoot(): Write first boot info to Central Repository "); + + CRepository* repository(NULL); + + TRAPD( err, repository = CRepository::NewL( KCRUidStartup ) ); + if ( err == KErrNone ) + { + err = repository->Set( KStartupFirstBoot, 1 ); + } + + delete repository; + TRACES("CStartupAppUi::MarkFirstBoot(): End"); + } + + +#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION +// --------------------------------------------------------------------------- +// CStartupAppUi::AnimationFinished() +// --------------------------------------------------------------------------- +void CStartupAppUi::AnimationFinished() + { + TRACES1("CStartupAppUi::AnimationFinished(): iInternalState=%d", iInternalState ); + + // first notify animation completion, it doesn't matter if it was canceled + if ( iAnimation->HasContent() ) + { + switch ( iInternalState ) + { + case EStartupShowingWelcomeAnimation: + UpdateStartupUiPhase( EStartupUiPhaseSystemWelcomeDone ); + break; + + case EStartupShowingOperatorAnimation: + UpdateStartupUiPhase( EStartupUiPhaseOperatorWelcomeDone ); + break; + + default: + TRACES("CStartupAppUi::AnimationFinished(): unknown state"); + break; + } + } + + + TInt err = KErrNone; + + if ( iAnimation->WasCancelled() ) + { + TRACES("Animations cancelled"); + + TRAP(err, DoNextStartupPhaseL( EStartupFirstBootAndRTCCheck )); + } + else if ( iInternalState == EStartupShowingWelcomeAnimation ) + { + TRAP(err, DoNextStartupPhaseL( EStartupShowingOperatorAnimation )); + } + else if ( iInternalState == EStartupShowingOperatorAnimation ) + { + 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::SetCleanBoot()"); + iCleanBoot = EStartupCleanBoot; + TRACES("CStartupAppUi::SetCleanBoot(): End"); + } + +// ---------------------------------------------------------------------------- +// CStartupAppUi::SimSupported() +// ---------------------------------------------------------------------------- +TBool CStartupAppUi::SimSupported() + { + 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 +// 10 EStartupWaitingStartupTone 11, 18 +// 11 EStartupShowingWelcomeAnimation 12, 14, 18 +// 12 EStartupWaitingCUIOperatorAnim 13, 18 +// 13 EStartupShowingOperatorAnimation 14, 14, 18 +// 14 EStartupShowingUserWelcomeNote 15, 18 +// 15 EStartupFirstBootAndRTCCheck 16, 18 +// 16 EStartupWaitingCUIStartupReady 17, 18 +// 17 EStartupStartupOK - +// 18 EStartupSystemFatalError - + +// --------------------------------------------------------------------------- + +void CStartupAppUi::DoNextStartupPhaseL( TStartupInternalState toState ) + { + TRACES("CStartupAppUi::DoNextStartupPhaseL()"); + TRACES2("CStartupAppUi::DoNextStartupPhaseL(): Change internal state from %d to %d", iInternalState, toState ); + + switch( iInternalState ) + { + case EStartupStartingUp: + { + switch( toState ) + { + case EStartupWaitingCriticalBlock: + iInternalState = EStartupWaitingCriticalBlock; + TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingCriticalBlock"); + WaitingCriticalBlockEndingL(); + break; + case EStartupSystemFatalError: + SystemFatalErrorL(); + break; + default: + __ASSERT_DEBUG( EFalse, + PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + break; + case EStartupWaitingCriticalBlock: + { + switch( toState ) + { + case EStartupWaitingCUIStartupReady: + iInternalState = EStartupWaitingCUIStartupReady; + TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingCUIStartupReady"); + 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: + __ASSERT_DEBUG( + EFalse, + PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + break; + case EStartupOfflineModeQuery: + { + switch( toState ) + { +#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION + case EStartupWaitingShowStartupAnimation: + iInternalState = EStartupWaitingShowStartupAnimation; + TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupWaitingShowStartupAnimation"); + WaitingStartupAnimationStartL(); + break; +#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: + iInternalState = EStartupShowingWelcomeAnimation; + TRACES("CStartupAppUi::DoNextStartupPhaseL(): InternalState : EStartupShowingWelcomeAnimation"); + DoStartupShowWelcomeAnimationL(); + break; + case EStartupSystemFatalError: + SystemFatalErrorL(); + break; + default: + __ASSERT_DEBUG( + EFalse, + PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + 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(); + break; + case EStartupSystemFatalError: + SystemFatalErrorL(); + break; + default: + __ASSERT_DEBUG( EFalse, + PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + break; +#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; + case EStartupSystemFatalError: + SystemFatalErrorL(); + break; + default: + __ASSERT_DEBUG( EFalse, + 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 : EStartupStartupOK"); + DoStartupEndPart(); + break; + case EStartupSystemFatalError: + SystemFatalErrorL(); + break; + default: + __ASSERT_DEBUG( EFalse, + PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + break; + case EStartupSystemFatalError: + { + switch( toState ) + { + 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 + //already in EStartupSystemFatalError + //so stop the execution of the other branch of + //the startup application. The other + //is displayin the "Selftest failed. Contact service"-dialog. + TRACES1("CStartupAppUi::DoNextStartupPhaseL(): InternalState : from EStartupSystemFatalError to %d -> so stop here.", toState ); + break; + default: + __ASSERT_DEBUG( EFalse, + PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + break; + default: + __ASSERT_DEBUG( EFalse, PANIC( EStartupInvalidInternalStateChange ) ); + break; + } + } + + +// --------------------------------------------------------------------------- +// CStartupAppUi::SystemFatalErrorL() +// Call this only from DoNextStartupPhaseL() +// --------------------------------------------------------------------------- +void CStartupAppUi::SystemFatalErrorL() + { + TRACES("CStartupAppUi::SystemFatalErrorL()"); + + iInternalState = EStartupSystemFatalError; + + TRACES("CStartupAppUi::SystemFatalErrorL(): End"); + } + +// --------------------------------------------------------------------------- +// CStartupAppUi::SimStatusChangedReset() +// --------------------------------------------------------------------------- +TBool CStartupAppUi::SimStatusChangedReset() + { + TRACES( "CStartupAppUi::SimStatusChangedReset()" ); + TBool ret_val( EFalse ); + if( !iFirstBoot ) + { + TInt startupReason( 0 ); + RProperty::Get( KPSUidStartup, KPSStartupReason, startupReason ); + ret_val = ( startupReason == ESIMStatusChangeReset ); + } + TRACES1( "CStartupAppUi::SimStatusChangedReset(): End, return %d", ret_val ); + return ret_val; + } + +#ifdef RD_STARTUP_ANIMATION_CUSTOMIZATION +// --------------------------------------------------------------------------- +// CStartupAppUi::UpdateStartupUiPhase() +// --------------------------------------------------------------------------- +void CStartupAppUi::UpdateStartupUiPhase( TInt aValue ) + { + TRACES1("CStartupAppUi::UpdateStartupUiPhase(): aValue=%d", aValue); + + TInt err = RProperty::Set( KPSUidStartup, KPSStartupUiPhase, aValue ); + + if( KErrNone != err ) + { + TRACES1("CStartupAppUi::UpdateStartupUiPhase(): KPSStartupUiPhase set err %d", err); + } + } +#endif // RD_STARTUP_ANIMATION_CUSTOMIZATION +// End of file