/*
* Copyright (c) 2003 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 CStartupOperatorAnimation.
*     Is used to show operator animation.
*
*/


// INCLUDE FILES
#include <aknappui.h>
#include <aknnotewrappers.h>
#include <barsread.h> //use of TResourceReader
#include <aknbitmapanimation.h>
#include "StartupOperatorAnimation.h"
#include <Startup.rsg>
#include "StartupDefines.h"
#include "Startup.hrh"
#include "StartupAppUi.h"
#include <operatoranimation.rsg>
#include <ConeResLoader.h>

// CONSTANTS

// Path to operator variated animation
_LIT( KOperatorAnimationResource, "z:operatoranimation.rsc" );

//Constants used in OfferKeyEventL
const TInt KTimerDelay( 10000);
const TInt KTimerInterval( 10000);

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

// ---------------------------------------------------------------------------
// CStartupOperatorAnimation::ConstructL(const TRect& aRect)
// Symbian 2nd phase constructor can leave.
// Need different ConstructL from base class CStartupWelcomeAnimation
// because different animation file and time are loaded.
// ---------------------------------------------------------------------------
void CStartupOperatorAnimation::ConstructL(const TRect& /*aRect*/)
    {
    TRACES("CStartupOperatorAnimation::ConstructL()");
    UpdateDrawInfo( EStartupDIStart );
    CreateWindowL();
    iAnimCancelTimer = CPeriodic::NewL( EPriorityNormal );

    TRACES("CStartupOperatorAnimation::ConstructL(): Animation loading started");
    iAnim = CAknBitmapAnimation::NewL();
    iAnim->ExcludeAnimationFramesFromCache();
    iAnim->SetContainerWindowL( *this );
    iAnim->SetScaleModeForAnimationFrames(EAspectRatioPreservedAndUnusedSpaceRemoved);
    TResourceReader rr;
    RConeResourceLoader loader( *CEikonEnv::Static() );

    TParse* fp = new(ELeave) TParse(); 
    fp->Set(KOperatorAnimationResource, &KDC_APP_RESOURCE_DIR, NULL);
    TRACES1("CStartupOperatorAnimation::ConstructL(): Operator animation resource path: '%S'", &fp->FullName());
    TFileName name( fp->FullName() );
    delete fp;

    TInt fileError = loader.Open( name );
    if ( fileError == KErrNone )
        {
        CleanupClosePushL( loader );
        iCoeEnv->CreateResourceReaderLC(rr, R_OPERATOR_IMAGE);
        TRAPD(err, iAnim->ConstructFromResourceL( rr ));
        TRACES1("CStartupOperatorAnimation::ConstructL(): Operator animation: err = %d", err);
        if( err == KErrNone )
            {
            TResourceReader timeReader;
            iCoeEnv->CreateResourceReaderLC(timeReader, R_ANIM_DURATION);
            iShowingTime = timeReader.ReadInt16();
            TRACES1("CStartupOperatorAnimation::ConstructL(): Operator animation showing time: %d", iShowingTime );
            CleanupStack::PopAndDestroy(); // pop timeReader
            }
        else
            {
            iShowingTime = 0;
            TRACES("CStartupOperatorAnimation::ConstructL(): Animation loading failed");
            }
        CleanupStack::PopAndDestroy(); //pop rr
        TRACES("CStartupOperatorAnimation::ConstructL(): Animation loading ended");
        CleanupStack::PopAndDestroy(); //pop loader
        }
    else
        {
        TRACES("CStartupOperatorAnimation::ConstructL(): Resource file loading failed");
        }

    
    SetRect(iAvkonAppUi->ApplicationRect());
    iAnim->SetPosition( TPoint( (iAvkonAppUi->ApplicationRect().Width()/2) - (iAnim->BitmapAnimData()->Size().iWidth/2), 
                                (iAvkonAppUi->ApplicationRect().Height()/2) - (iAnim->BitmapAnimData()->Size().iHeight/2) ) );
    ActivateL();

    TRACES("CStartupOperatorAnimation::ConstructL(): End");
    }

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

// ---------------------------------------------------------
// CStartupOperatorAnimation::CStartupOperatorAnimation()
// ---------------------------------------------------------
CStartupOperatorAnimation::CStartupOperatorAnimation( CStartupAppUi* aStartupAppUi ) : 
    CStartupWelcomeAnimation(aStartupAppUi)
    { 
    TRACES("CStartupOperatorAnimation::CStartupOperatorAnimation()");
    iShowingTime = 0;
    }

// ---------------------------------------------------------------------------
// CStartupOperatorAnimation::OfferKeyEventL(...)
// ---------------------------------------------------------------------------
TKeyResponse CStartupOperatorAnimation::OfferKeyEventL(const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)
    {
    TRACES("CStartupWelcomeAnimation::OfferKeyEventL()");
    if( iAnimationShowing && !iStartupAppUi->HiddenReset() && !iAnimationCancelled )
        {
        // Cancel animation
        UpdateDrawInfo( EStartupDIOperatorAnimCancelled );
        EndAnimation();
        TRACES("CStartupWelcomeAnimation::OfferKeyEventL(): Timer activated - before");
        iAnimCancelTimer->Start( KTimerDelay, KTimerInterval,
            TCallBack( iStartupAppUi->DoStopTimingL, iStartupAppUi ) );
        TRACES("CStartupOperatorAnimation::OfferKeyEventL(): Timer activated - after");
        iAnimationCancelled = ETrue;
        }
    else if( !iAnimationShowing && iStartupAppUi->OperatorTonePlaying())
        {
        TRACES("CStartupOperatorAnimation::OfferKeyEventL() Animation has completed but tone is still playing. Stop it.");
        iStartupAppUi->StopOperatorTone();
        }

    TRACES("CStartupOperatorAnimation::OfferKeyEventL(): End");
    return EKeyWasConsumed;
    }

// ---------------------------------------------------------------------------
// CStartupOperatorAnimation::DoDrawing()
// ---------------------------------------------------------------------------
void CStartupOperatorAnimation::DoDrawing() const
    {
//    These are the cases handled in this function
//    EStartupDIOperatorAnimStart,
//    EStartupDIOperatorAnimCancelled,
//    EStartupDIOperatorAnimEnd
//    EStartupDISystemFatalError
    TRACES("CStartupOperatorAnimation::DoDrawing()");
    TRACES1("CStartupOperatorAnimation::DoDrawing():  %d ", iDrawUpdateInfo );
    switch ( iDrawUpdateInfo )
        {

        case EStartupDIOperatorAnimStart:
            {
            TRACES("CStartupOperatorAnimation::DoDrawing(): EStartupDIOperatorAnimStart");
            }
            break;
        case EStartupDIOperatorAnimCancelled:
            {
            TRACES("CStartupOperatorAnimation::DoDrawing(): EStartupDIOperatorAnimCancelled");
            EndAnimation();
            TRAPD(err,iStartupAppUi->StopTimingL());
            if (err != KErrNone)
                {
                TRACES1("CStartupOperatorAnimation::DoDrawing(): StopTimingL() leaves, err = %d", err );
                }
            }
            break;
        case EStartupDIOperatorAnimEnd:
            {
            TRACES("CStartupOperatorAnimation::DoDrawing(): EStartupDIOperatorAnimEnd");
            }
            break;
        case EStartupDISystemFatalError:
            {
            }
            break;
        default:
            break;
        }
    }