/*

* Copyright (c) 2007,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:  Implementation of CStartupAnimationWrapper class

*

*/

#include <apgtask.h>

#include <e32debug.h>

#include <e32property.h>

#include <startupdomainpskeys.h>

#include "startupanimationwrapper.h"

#include "startup.hrh"

#include "StartupDefines.h"

#include "startupview.h"

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

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

// CStartupAnimationWrapper::NewL

//

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

//

CStartupAnimationWrapper* CStartupAnimationWrapper::NewL( CStartupView& aView )

    {

    TRACES("CStartupAnimationWrapper::NewL()");

    CStartupAnimationWrapper* self =

        new( ELeave ) CStartupAnimationWrapper( aView );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACES("CStartupAnimationWrapper::NewL(): End");

    return self;

    }

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

// CStartupAnimationWrapper::~CStartupAnimationWrapper

//

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

//

CStartupAnimationWrapper::~CStartupAnimationWrapper()

    {

    TRACES("CStartupAnimationWrapper::~CStartupAnimationWrapper()");

    Cancel();

    if ( iCallBackCaller )

        {

        iCallBackCaller->Cancel();

        }

    delete iCallBackCaller;

    delete iCtrl;

    TRACES("CStartupAnimationWrapper::~CStartupAnimationWrapper(): end");

    }

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

// CStartupAnimationWrapper::PreLoad

//

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

//

void CStartupAnimationWrapper::PreLoad(

    const TRect& aRect,

    const CCoeControl& aContainer,

    const CSAnimStartupCtrl::TAnimationParams& aParams,

    const TBool aPlayDefaultBeep,

    const TInt aSyncCommand )

    {

    TRACES1("CStartupAnimationWrapper::PreLoad(), iState = %d", iState);

    if ( iState == EIdle ) // This component will not be re-used if first animation is cancelled

        {

        TRAPD( errorCode,

            LoadL( aRect, aContainer, aParams, aPlayDefaultBeep, aSyncCommand ) );

        if ( errorCode != KErrNone )

            {

            TRACES1("CStartupAnimationWrapper::LoadL() leave code = %d", errorCode);

            DestroyCtrl();

            }

        }

    TRACES("CStartupAnimationWrapper::PreLoad(): End");

    }

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

// CStartupAnimationWrapper::Play

//

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

//

void CStartupAnimationWrapper::Play(

    const TRect& aRect,

    const CCoeControl& aContainer,

    const CSAnimStartupCtrl::TAnimationParams& aParams,

    const TBool aPlayDefaultBeep,

    const TInt aSyncCommand,

    const TCallBack& aCallBack )

    {

    TRACES("CStartupAnimationWrapper::Play()");

    iCallBackCaller->Set( aCallBack );

    if ( iState == ELoading )

        {

        iPlayImmediately = ETrue;

        }

    else if ( iState == EReady )

        {

        StartPlaying();

        }

    else if ( iState == EIdle )

        {

        iPlayImmediately = ETrue;

        TRAPD( errorCode,

            LoadL( aRect, aContainer, aParams, aPlayDefaultBeep, aSyncCommand ) );

        if ( errorCode != KErrNone )

            {

            TRACES1("CStartupAnimationWrapper::LoadL() leave code = %d", errorCode);

            DestroyCtrl();

            iCallBackCaller->CallBack();

            }

        }

    TRACES("CStartupAnimationWrapper::Play(): End");

    }

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

// CStartupAnimationWrapper::WasCancelled

//

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

//

TBool CStartupAnimationWrapper::WasCancelled() const

    {

    return ( iState == ECancelled );

    }

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

// CStartupAnimationWrapper::DoCancel

//

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

//

void CStartupAnimationWrapper::DoCancel()

    {

    TRACES("CStartupAnimationWrapper::DoCancel()");

    iState = ECancelled;

    DestroyCtrl();

    iCallBackCaller->CallBack();

    TRACES("CStartupAnimationWrapper::DoCancel(): End");

    }

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

// CStartupAnimationWrapper::RunL

//

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

//

void CStartupAnimationWrapper::RunL()

    {

    TRACES1("CStartupAnimationWrapper::RunL(): iStatus = %d", iStatus.Int());

    if ( iState == ELoading && iStatus.Int() == KErrNone )

        {

        iState = EReady;

        if ( iPlayImmediately )

            {

            StartPlaying();

            }

        }

    else

        {

        iState = ( iStatus.Int() == KErrCancel ? ECancelled : EIdle );

        DestroyCtrl();

        iCallBackCaller->CallBack();

        }

    TRACES("CStartupAnimationWrapper::RunL(): End");

    }

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

// CStartupAnimationWrapper::CStartupAnimationWrapper

//

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

//

CStartupAnimationWrapper::CStartupAnimationWrapper( CStartupView& aView )

  : CActive( EPriorityStandard ),

    iView( aView ),

    iState( EIdle ),

    iHasContent( EFalse )

    {

    TRACES("CStartupAnimationWrapper::CStartupAnimationWrapper()");

    CActiveScheduler::Add( this );

    TRACES("CStartupAnimationWrapper::CStartupAnimationWrapper(): End");

    }

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

// CStartupAnimationWrapper::ConstructL

//

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

//

void CStartupAnimationWrapper::ConstructL()

    {

    TRACES("CStartupAnimationWrapper::ConstructL()");

    TRACES("CStartupAnimationWrapper::ConstructL(): End");

    iCallBackCaller = new ( ELeave ) CAsyncCallBack( EPriorityStandard );

    }

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

// CStartupAnimationWrapper::LoadL

//

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

//

void CStartupAnimationWrapper::LoadL(

    const TRect& /*aRect*/,

    const CCoeControl& aContainer,

    const CSAnimStartupCtrl::TAnimationParams& aParams,

    const TBool aPlayDefaultBeep,

    const TInt aSyncCommand )

    {

    TRACES("CStartupAnimationWrapper::LoadL()");

    __ASSERT_DEBUG( !iCtrl, PANIC( EStartupPanicClassMemberVariableIsNotNull ) );

    __ASSERT_DEBUG( iState == EIdle, PANIC( EStartupInvalidInternalState ) );

    iCtrl = CSAnimStartupCtrl::NewL( iView.Rect(), aContainer );

    iView.SetComponent( *iCtrl );

    iState = ELoading;

    iCtrl->Load( aParams, aPlayDefaultBeep, aSyncCommand, iStatus );

    iHasContent = iCtrl->HasContent();

    SetActive();

    TRACES("CStartupAnimationWrapper::LoadL(): End");

    }

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

// CStartupAnimationWrapper::StartPlaying

//

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

//

void CStartupAnimationWrapper::StartPlaying()

    {

    TRACES("CStartupAnimationWrapper::StartPlaying()");

    iState = EPlaying;

    RProperty::Set( KPSUidStartup, KPSSplashShutdown, ESplashShutdown );

    BringToForeground();

    iCtrl->Start( iStatus );

    SetActive();

    TRACES("CStartupAnimationWrapper::StartPlaying(): End");

    }

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

// CStartupAnimationWrapper::DestroyCtrl

//

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

//

void CStartupAnimationWrapper::DestroyCtrl()

    {

    TRACES("CStartupAnimationWrapper::DestroyCtrl()");

    if ( iCtrl )

        {

        iCtrl->Cancel();

        iView.RemoveComponent();

        delete iCtrl;

        iCtrl = NULL;

        }

    TRACES("CStartupAnimationWrapper::DestroyCtrl(): End");

    }

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

// CStartupAnimationWrapper::HasContent

//

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

//

TBool CStartupAnimationWrapper::HasContent() const

    {

    return iHasContent;

    }

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

// CStartupAnimationWrapper::BringToForeground

//

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

//

void CStartupAnimationWrapper::BringToForeground()

    {

    TRACES("CStartupAnimationWrapper::BringToForeground()");

    TApaTask self( CCoeEnv::Static()->WsSession() );

    self.SetWgId( CCoeEnv::Static()->RootWin().Identifier() );

    self.BringToForeground();

    TRACES("CStartupAnimationWrapper::BringToForeground(): End");

    }