/*
* Copyright (c) 2002 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:  
*     This class is the container class of the CStartupWelcomeAnimation.
*     Is used to show welcome animation.
*
*/


// INCLUDE FILES
#include <aknappui.h>
#include <aknnotewrappers.h>
#include <barsread.h> //use of TResourceReader
#include <StarterClient.h>     //used for RemoveSplashScreen
#include <aknbitmapanimation.h>
#include <startup.mbg>
#include "StartupWelcomeAnimation.h"
#include <Startup.rsg>
#include "StartupDefines.h"
#include "Startup.hrh"
#include "StartupAppUi.h"
#include <akniconutils.h>

// CONSTANTS
const TInt KStartupAnimationShowingDuration( 4200 );//4.2 sec

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

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::ConstructL(const TRect& aRect)
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::ConstructL(const TRect& /*aRect*/)
    {
    TRACES("CStartupWelcomeAnimation::ConstructL()");
    iShowingTime = KStartupAnimationShowingDuration;
    UpdateDrawInfo( EStartupDIStart );

    iAvkonAppUi->StatusPane()->MakeVisible(EFalse);
    CreateWindowL();
    iAnimCancelTimer = CPeriodic::NewL( EPriorityNormal );

    TRACES("CStartupWelcomeAnimation::ConstructL(): animation loading started");
    iAnim = CAknBitmapAnimation::NewL();
    iAnim->ExcludeAnimationFramesFromCache();
    iAnim->SetContainerWindowL( *this );
    iAnim->SetScaleModeForAnimationFrames(EAspectRatioPreservedAndUnusedSpaceRemoved);
    TResourceReader rr;
    iCoeEnv->CreateResourceReaderLC(rr, R_ANIM_IMAGE);
    TRAPD(err, iAnim->ConstructFromResourceL( rr ))
    if (err != KErrNone)
        {
        TRACES1("CStartupWelcomeAnimation::ConstructL(): ConstructFromResourceL() leaves, err = %d", err );
        }
    CleanupStack::PopAndDestroy();

    SetRect(iAvkonAppUi->ApplicationRect());  // Results in a call to SizeChanged()
    ActivateL();

    TRACES("CStartupWelcomeAnimation::ConstructL(): animation loading ended");
    TRACES("CStartupWelcomeAnimation::ConstructL(): End");
    }

// -----------------------------------------------------------------------------
// CStartupWelcomeAnimation::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CStartupWelcomeAnimation* CStartupWelcomeAnimation::NewL( CStartupAppUi* aStartupAppUi,
                                                          const TRect& aRect)
    {
    TRACES("CStartupWelcomeAnimation::NewL()");
    CStartupWelcomeAnimation* self = new (ELeave) CStartupWelcomeAnimation( aStartupAppUi );
    CleanupStack::PushL(self);
    self->ConstructL(aRect);
    CleanupStack::Pop();
    TRACES("CStartupWelcomeAnimation::NewL(): End");
    return self;
    }

// ---------------------------------------------------------
// CStartupWelcomeAnimation::CStartupWelcomeAnimation()
// ---------------------------------------------------------
CStartupWelcomeAnimation::CStartupWelcomeAnimation( CStartupAppUi* aStartupAppUi ) :
    iBackgroundBitmap( NULL ),
    iSplashScreenRemoved( EFalse ),
    iStartupAppUi( aStartupAppUi ),
    iAnimationShowing( EFalse ),
    iAnimationCancelled ( EFalse )
    {
    TRACES("CStartupWelcomeAnimation::CStartupWelcomeAnimation()");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::StartL()
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::StartL()
    {
    TRACES("CStartupWelcomeAnimation::StartL()");
    iAnim->StartAnimationL();
    ControlEnv()->WsSession().Flush(); // force draw of the context
    TRACES("CStartupWelcomeAnimation::StartL(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::UpdateDrawInfo( TStartupDrawInfo aValue )
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::UpdateDrawInfo( TStartupDrawInfo aValue )
    {
    TRACES("CStartupWelcomeAnimation::UpdateDrawInfo()");
    TRACES1("CStartupWelcomeAnimation::UpdateDrawInfo(): Value %d", aValue);
    //Prevent state change if already EStartupDISystemFatalError
    if( iDrawUpdateInfo == EStartupDISystemFatalError )
        {
        TRACES("CStartupWelcomeAnimation::UpdateDrawInfo(): End, preventing state change - EStartupDISystemFatalError");
        return;
        }

    iDrawUpdateInfo = aValue;
    TRACES("CStartupWelcomeAnimation::UpdateDrawInfo(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::DoDrawingL()
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::DoDrawingL() const
    {
    TRACES("CStartupWelcomeAnimation::DoDrawingL()");
    switch ( iDrawUpdateInfo )
        {
        case EStartupDIStart:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIStart");
            DrawBlankScreen(); // clears screen after code query emergency call
            }
            break;
        case EStartupDITouchScreenCalib:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDITouchScreenCalib");
            RemoveSplashScreen();
            DrawBlankScreen();
            }
            break;
        case EStartupDICharging:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDICharging");
            RemoveSplashScreen();
            DrawBlankScreen();
            }
            break;
        case EStartupDIAlarm:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIAlarm");
            RemoveSplashScreen();
            DrawBlankScreen();
            }
            break;
        case EStartupDIHiddenReset:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIHiddenReset");
            RemoveSplashScreen();
            DrawBlankScreen();            
            }
            break;
        case EStartupDIQueriesOn:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIQueriesOn");
            RemoveSplashScreen();
            DrawBlankScreen();
            }
            break;
        case EStartupDIQueriesOff:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIQueriesOff");
            }
            break;
        case EStartupDIWelcomeAnimStart:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIWelcomeAnimStart");
			RemoveSplashScreen();
			DrawBlankScreen();
            }
            break;
        case EStartupDIWelcomeAnimCancelled:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIWelcomeAnimCancelled");
            }
            break;
        case EStartupDIWelcomeAnimEnd:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIWelcomeAnimEnd");
            DrawBlankScreen();
            }
            break;
        case EStartupDIOperatorAnimEnd:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIOperatorAnimEnd");
            DrawBlankScreen();
            }
            break;
        case EStartupDICityTimeDateQueries:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDICityTimeDateQueries");
            DrawBlankScreen();
            }
            break;
        case EStartupDIEnd:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDIEnd");
            }
            break;
        case EStartupDISystemFatalError:
            {
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): EStartupDISystemFatalError");
            }
            break;
        default:
            TRACES("CStartupWelcomeAnimation::DoDrawingL(): default");
            break;
        }
    TRACES("CStartupWelcomeAnimation::DoDrawingL(): End");
    }

// ---------------------------------------------------------
// CStartupWelcomeAnimation::RemoveSplashScreen()
// ---------------------------------------------------------
void CStartupWelcomeAnimation::RemoveSplashScreen() const
    {
    TRACES("CStartupWelcomeAnimation::RemoveSplashScreen()");
    //Remove SplashScreen
    if( !iSplashScreenRemoved )
        {
        TRACES("CStartupWelcomeAnimation::RemoveSplashScreen(): Connect to Starter");
        RStarterSession startersession;
        if( startersession.Connect() == KErrNone )
            {
            TRACES("CStartupWelcomeAnimation::RemoveSplashScreen(): Connected to Starter");
            startersession.EndSplashScreen();
            TRACES("CStartupWelcomeAnimation::RemoveSplashScreen(): Splash screen removed");
            startersession.Close();
            }
        }
    TRACES("CStartupWelcomeAnimation::RemoveSplashScreen(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::~CStartupWelcomeAnimation()
// ---------------------------------------------------------------------------
CStartupWelcomeAnimation::~CStartupWelcomeAnimation()
    {
    TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation()");

    if( iAnim )
        {
        if( iAnimationShowing )
            {
            iAnim->CancelAnimation();
            TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation(): Animation cancelled");
            }
        }
    delete iAnim;
    TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation(): iAnim deleted");

    if (iBackgroundBitmap)
        {
        delete iBackgroundBitmap;
        TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation(): iBackgroundBitmap deleted");
        }

    if( iAnimCancelTimer )
        {
        iAnimCancelTimer->Cancel();
        TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation(): Timer cancelled");
        }
    delete iAnimCancelTimer;
    TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation(): iAnimCancelTimer deleted");

    TRACES("CStartupWelcomeAnimation::~CStartupWelcomeAnimation(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::ComponentControl(TInt aIndex)
// ---------------------------------------------------------------------------
CCoeControl* CStartupWelcomeAnimation::ComponentControl(TInt aIndex) const
    {
    switch ( aIndex )
        {
        case 0:
            {
            return iAnim;
            }
        default:
            {
            return NULL;
            }
        }
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::CountComponentControls()
// ---------------------------------------------------------------------------
TInt CStartupWelcomeAnimation::CountComponentControls() const
    {
    return iAnim ? 1 : 0; // return nbr of controls inside this container
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::Draw(const TRect& aRect) const
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::Draw(const TRect& /*aRect*/ ) const
    {
    TRACES("CStartupWelcomeAnimation::Draw()");
    TRAPD(err, DoDrawingL());
    if (err != KErrNone)
        {
        TRACES1("CStartupWelcomeAnimation::Draw(): DoDrawingL() leaves, err = %d", err );
        }
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::DrawBlankScreen() const
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::DrawBlankScreen() const
    {
    TRACES("CStartupWelcomeAnimation::DrawBlankScreen()");
    CWindowGc& gc = SystemGc();
    TRect rect = Rect();
    gc.SetPenStyle(CGraphicsContext::ENullPen);
    gc.SetBrushColor(KRgbWhite);
    gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
    gc.DrawRect(rect);
    ControlEnv()->WsSession().Flush(); // force draw of the context
    TRACES("CStartupWelcomeAnimation::DrawBlankScreen(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::ShowingTime()
// ---------------------------------------------------------------------------
TInt CStartupWelcomeAnimation::ShowingTime()
    {
    TRACES1("CStartupWelcomeAnimation::ShowingTime(): time = %d", iShowingTime);
    return iShowingTime;
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::SizeChanged()
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::SizeChanged()
    {
    if( iAnim )
        {
        iAnim->SetRect(Rect());
        iAnim->SetPosition( TPoint(
            (iAvkonAppUi->ApplicationRect().Width()/2) - (iAnim->BitmapAnimData()->Size().iWidth/2), 
            (iAvkonAppUi->ApplicationRect().Height()/2) - (iAnim->BitmapAnimData()->Size().iHeight/2)
            ) );
        }
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::EndAnimation()
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::EndAnimation() const
    {
    TRACES("CStartupWelcomeAnimation::EndAnimation()");
    if( iAnim )
        {
        TRACES("CStartupWelcomeAnimation::EndAnimation(): Cancel animation");
        iAnim->CancelAnimation();
        }
    TRACES("CStartupWelcomeAnimation::EndAnimation(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::HandleControlEventL(...)
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::HandleControlEventL(
        CCoeControl* /*aControl*/,
        TCoeEvent /*aEventType*/)
    {
    //pure virtual from MCoeControlObserver
    TRACES("CStartupWelcomeAnimation::HandleControlEventL()");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::HandlePointerEventL(...)
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::HandlePointerEventL(const TPointerEvent& aPointerEvent)
    {
    TRACES("CStartupWelcomeAnimation::HandlePointerEventL()");
    if (AknLayoutUtils::PenEnabled())
        {
        TRACES1("CStartupWelcomeAnimation::HandlePointerEventL: aPointerEvent.iType == %d",aPointerEvent.iType );
        switch (aPointerEvent.iType)
            {
            case TPointerEvent::EButton1Down:
                CancelAnimation();
                break;                    

            default:
                break;
            }
        }
    TRACES("CStartupWelcomeAnimation::HandlePointerEventL(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::OfferKeyEventL(...)
// ---------------------------------------------------------------------------
TKeyResponse CStartupWelcomeAnimation::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode /*aType*/ )
    {
    TRACES("CStartupWelcomeAnimation::OfferKeyEventL()");
    TRACES1("CStartupWelcomeAnimation::OfferKeyEventL(): aKeyEvent.iCode == %d",aKeyEvent.iCode);
    TRACES1("CStartupWelcomeAnimation::OfferKeyEventL(): aKeyEvent.iScanCode == %d",aKeyEvent.iScanCode);
    TRACES1("CStartupWelcomeAnimation::OfferKeyEventL(): iAnimationShowing == %d",iAnimationShowing);
    TRACES1("CStartupWelcomeAnimation::OfferKeyEventL(): iAnimationCancelled == %d",iAnimationCancelled);
    
    if ( iStartupAppUi->GetOfflineModeQueryShown() )
        {
        TRACES("CStartupWelcomeAnimation::OfferKeyEventL(): Key event from offline mode query");
        // first key event comes from Offline Mode Query
        iStartupAppUi->SetOfflineModeQueryShown( EFalse );
        }
    else
        {
        if( iAnimationShowing && !iStartupAppUi->HiddenReset() && !iAnimationCancelled )
            {
            if (aKeyEvent.iScanCode == EStdKeyNkpAsterisk || aKeyEvent.iScanCode == 0x2a)
                {               
                TRACES("CStartupWelcomeAnimation::OfferKeyEventL(): Set clean boot");
                iStartupAppUi->SetCleanBoot();                
                }        
            // Cancel animation
            CancelAnimation();
            }
        else if( !iAnimationShowing && iStartupAppUi->StartupTonePlaying())
            {
            TRACES("CStartupWelcomeAnimation::OfferKeyEventL() Animation has completed but tone is still playing. Stop it.");
            iStartupAppUi->StopStartupTone();
            }
        }
    
    TRACES("CStartupWelcomeAnimation::OfferKeyEventL(): End");
    return EKeyWasConsumed;
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::CancelAnimCancelTimer()
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::CancelAnimCancelTimer()
    {
    TRACES("CStartupWelcomeAnimation::CancelAnimCancelTimer()");
    iAnimCancelTimer->Cancel();
    TRACES("CStartupWelcomeAnimation::CancelAnimCancelTimer(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::CancelAnimation(...)
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::CancelAnimation()
    {
    TRACES("CStartupWelcomeAnimation::CancelAnimation()");
    if( iAnimationShowing && !iStartupAppUi->HiddenReset() && !iAnimationCancelled )
        {
        UpdateDrawInfo( EStartupDIWelcomeAnimCancelled );
        EndAnimation();
        TRACES("CStartupWelcomeAnimation::CancelAnimation(): Timer activated - before");
        iAnimCancelTimer->Start( 10000, 10000, 
                           TCallBack( iStartupAppUi->DoStopTimingL, iStartupAppUi ) );
        TRACES("CStartupWelcomeAnimation::CancelAnimation(): Timer activated - after");
        iAnimationCancelled = ETrue;
        }
    TRACES("CStartupWelcomeAnimation::CancelAnimation(): End");
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::IsAnimationCancelled(...)
// ---------------------------------------------------------------------------
TBool CStartupWelcomeAnimation::IsAnimationCancelled()
    {
    TRACES1("CStartupWelcomeAnimation::IsAnimationCancelled(): iAnimationCancelled: %d", iAnimationCancelled);
    return iAnimationCancelled;
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::SetAnimationShowing(...)
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::SetAnimationShowing(TBool aValue)
    {
    TRACES("CStartupWelcomeAnimation::SetAnimationShowing()");
    TRACES2("CStartupWelcomeAnimation::SetAnimationShowing(): iAnimationShowing changed from %d to %d",iAnimationShowing, aValue );
    iAnimationShowing = aValue;
    }

// ---------------------------------------------------------------------------
// CStartupWelcomeAnimation::HandleResourceChange(...)
// ---------------------------------------------------------------------------
void CStartupWelcomeAnimation::HandleResourceChange(TInt aType)
    {
    CCoeControl::HandleResourceChange(aType);
    if(aType==KEikDynamicLayoutVariantSwitch)
        {
        SetRect(iAvkonAppUi->ApplicationRect()); // update rect
        }
   }



//  End of File