/*

* Copyright (c) 2004-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:  Animates effect queues.

*

*/

// INCLUDE FILES

#include <hal.h>

#include <hal_data.h>

#include <AknsUtils.h>

#include <babitflags.h>

#include <hwrmlightdomaincrkeys.h>

#include "AknsRlEffectPlugin.h"

#include "AknsRlCommand.h"

#include "AknsAppSkinInstance.h"

#include "AknsAlAnimatorBmp.h"

#include "AknsAlShared.h"

#include "AknsAlAnimationFactory.h"

#include "AknsAlEffectContext.h"

#include "AknsAlDataAccess.h"

#include <AknsEffectAnim.h> // For the animation state enum

#include "AknsDebug.h"

// CONSTANTS

const TInt KAlMaxDeltaTime = 65536; // In milliseconds, ~65 seconds

// =============================== HELPERS =====================================

/**

* Utility class for binding size changes to animation value parameters.

*/

NONSHARABLE_CLASS( CAknsAlSizeBoundParam ):

    public CBase,

    public MAknsRlParameterIterator

    {

    private:

        // Internal flag indices

        enum TFlag

            {

            EFlagW    = 0,

            EFlagH    = 1,

            EFlagIter = 2

            };

    protected:

        CAknsAlSizeBoundParam();

        void ConstructL( MAknsAlAnimationValue* aValue,

                         const TDesC& aName, TInt aFlags );

    public:

        ~CAknsAlSizeBoundParam();

        static CAknsAlSizeBoundParam* NewL( MAknsAlAnimationValue* aValue,

                                            const TDesC& aName, TInt aFlags );

        void SizeChangedL( const TSize& aNewSize );

    public: // Implementation of MAknsRlParameterIterator

        TBool HasNext();

        const TAknsRlParameterData* NextL();

    private:

        // Referenced only

        MAknsAlAnimationValue* iAnimationValue;

        // Owned

        HBufC* iName;

        /// Combines the x, y, xy flags with interator flag.

        TBitFlags32 iFlags;

        TAknsRlParameterData iIteratorData;

        // Stores the current size

        TBuf16<2> iSize;

    };

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

// CAknsAlSizeBoundParam::CAknsAlSizeBoundParam

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

//

CAknsAlSizeBoundParam::CAknsAlSizeBoundParam()

    {

    // Derived from CBase -> members are zeroed

    }

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

// CAknsAlSizeBoundParam::ConstructL

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

//

void CAknsAlSizeBoundParam::ConstructL( MAknsAlAnimationValue* aValue,

                                        const TDesC& aName, TInt aFlags )

    {

    if( NULL == aValue )

        User::Leave( KErrArgument );

    iAnimationValue = aValue;

    iName  = aName.AllocL();

    iFlags.SetValue( aFlags );

    iSize.SetLength( 2 );

    }

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

// CAknsAlSizeBoundParam::~CAknsAlSizeBoundParam

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

//

CAknsAlSizeBoundParam::~CAknsAlSizeBoundParam()

    {

    delete iName; //lint

    iAnimationValue = NULL; // Removes lint nag

    }

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

// CAknsAlSizeBoundParam::NewL

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

//

CAknsAlSizeBoundParam* CAknsAlSizeBoundParam::NewL(

    MAknsAlAnimationValue* aValue,

    const TDesC& aName,

    TInt aFlags )

    {

    CAknsAlSizeBoundParam* self = new(ELeave) CAknsAlSizeBoundParam();

    CleanupStack::PushL( self );

    self->ConstructL( aValue, aName, aFlags );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknsAlSizeBoundParam::SizeChangedL

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

//

void CAknsAlSizeBoundParam::SizeChangedL( const TSize& aNewSize )

    {

    iSize[0] = TInt16( aNewSize.iWidth );

    iSize[1] = TInt16( aNewSize.iHeight );

    // Push the changed parameter to animation value

    iFlags.Set( EFlagIter );

    iAnimationValue->SetParametersL( *this );

    }

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

// CAknsAlSizeBoundParam::HasNext

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

//

TBool CAknsAlSizeBoundParam::HasNext()

    {

    if( !iFlags.IsSet( EFlagIter ) )

        return ETrue;

    return EFalse;

    }

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

// CAknsAlSizeBoundParam::NextL

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

//

const TAknsRlParameterData* CAknsAlSizeBoundParam::NextL()

    {

    if( iFlags.IsSet( EFlagIter ) )

        User::Leave( KErrOverflow );

    iIteratorData.iName = iName;

    if( iFlags.IsSet( EFlagW ) && iFlags.IsSet( EFlagH ) )

        {

        iIteratorData.iType   = EAknsRlParameterTypeString;

        iIteratorData.iString = &iSize;

        }

    else if( iFlags.IsSet( EFlagW ) )

        {

        iIteratorData.iType   = EAknsRlParameterTypeNumber;

        iIteratorData.iNumber = iSize[0];

        }

    else // Must be EFlagH

        {

        iIteratorData.iType   = EAknsRlParameterTypeNumber;

        iIteratorData.iNumber = iSize[1];

        }

    // Mark the iterator flag

    iFlags.Set( EFlagIter );

    return &iIteratorData;

    }

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

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

// CAknsAlAnimatorBmp::CAknsAlAnimatorBmp

// C++ default constructor can NOT contain any code, that might leave.

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

//

CAknsAlAnimatorBmp::CAknsAlAnimatorBmp( MAknsEffectAnimObserver* aObserver ):

    iObserver( aObserver )

    {

    // Derived from CBase, members zeroed

    }

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

// CAknsAlAnimatorBmp::ConstructL

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

//

void CAknsAlAnimatorBmp::ConstructL()

    {

    iState = EAknsAnimStateStopped;

    iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    User::LeaveIfError( HAL::Get( HALData::ESystemTickPeriod, iMsPerTick ) );

    // HAL returns microseconds, convert to milliseconds

    iMsPerTick = iMsPerTick / 1000;

    iContext = CAknsAlEffectContext::NewL();

    iLightsClient = CHWRMLight::NewL( this );

    }

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

// Destructor

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

//

CAknsAlAnimatorBmp::~CAknsAlAnimatorBmp()

    {

    /*lint -save -e1551 */ // No exceptions are thrown

    // Release effect filters

    TInt count = iAnimationCommands.Count();

    for( TInt i=0; i < count; i++ )

        {

        // Activate effects

        CAknsAlAnimationCommand* cmd = iAnimationCommands[i];

        MAknsRlEffect* effect = cmd->Effect();

        effect->Deactivate();

        effect->Release();

        }

    delete iTimer;

    delete iContext;

    iPreprocessCommands.ResetAndDestroy();

    iAnimationCommands.ResetAndDestroy();

    iValueContainers.ResetAndDestroy();

    iTimingModels.ResetAndDestroy();

    iSizeBoundParams.ResetAndDestroy();

    delete iLightsClient;

    /*lint -restore */

    }

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

// CAknsAlAnimatorBmp::NewL

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

//

CAknsAlAnimatorBmp* CAknsAlAnimatorBmp::NewL(  MAknsEffectAnimObserver* aObserver )

    {

    if( !aObserver )

        User::Leave( KErrArgument );

    CAknsAlAnimatorBmp* self = new(ELeave) CAknsAlAnimatorBmp( aObserver );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CAknsAlAnimatorBmp::ConstructFromSkinL

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

//

TBool CAknsAlAnimatorBmp::ConstructFromSkinL( const TAknsItemID& aItemID )

    {

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if( NULL == skin )

        User::Leave( KErrBadHandle );

    // TODO: We need to pass skin server session to bitmap context (it is

    // required by ApplyGfx plugin). This is bad style but this is currently

    // the only way to do it (without BC break). In ideal case you could query

    // the server session via the skin instance interface. Note that by

    // referring to AppSkinInstance we create an unwanted dependency to other

    // parts of skin library. Fortunately, there is no need to link

    // AppSkinInstance as we are using the session member directly.

    CAknsAppSkinInstance* appSkin = static_cast<CAknsAppSkinInstance*>(skin); //lint !e1774 dynamic_cast not allowed

    iContext->SetSkinSrvSession( &appSkin->iSession );

    // Query animation instructions from skin

    CAknsItemData* item = skin->GetCachedItemData( aItemID, EAknsITAnimation );

    if( !item )

        return EFalse; // Item was not found

    // Querying EAknsITAnimation quarantees that the pointer is of right type

    CAknsAnimationItemData* skinData = static_cast<CAknsAnimationItemData*>( item ); //lint !e1774 dynamic_cast not allowed

    // Morphing animations are not for highlights

    if( skinData->Morphing() )

        {

        return EFalse; // Item was found, but we ignore morphing animations

        }

    iMinimumInterval = skinData->MinInterval();

    iInputLayerMode   = skinData->InputLayerMode();

    iInputLayerIndex  = skinData->InputLayer();

    iOutputLayerMode  = skinData->OutputLayerMode();

    iOutputLayerIndex = skinData->OutputLayer();

    CreateTimingModelsL( *skinData );

    CreateAnimationValueContainersL( *skinData );

    CreatePreprocessCommandsL( *skinData );

    CreateAnimationCommandsL( *skinData );

    CreateSizeBoundParamsL( *skinData );

    return ETrue;

    }

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

// CAknsAlAnimatorBmp::ConstructFromItemL

// Testing time functionality only.

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

//

TBool CAknsAlAnimatorBmp::ConstructFromItemL( const CAknsAnimationItemData& aData,

                                              RAknsSrvSession* aSession )

    {

    // Morphing animations are not for highlights

    if( aData.Morphing() )

        {

        return EFalse; // Item was found, but we ignore morphing animations

        }

    iContext->SetSkinSrvSession( aSession );

    iMinimumInterval = aData.MinInterval();

    iInputLayerMode   = aData.InputLayerMode();

    iInputLayerIndex  = aData.InputLayer();

    iOutputLayerMode  = aData.OutputLayerMode();

    iOutputLayerIndex = aData.OutputLayer();

    CreateTimingModelsL( aData );

    CreateAnimationValueContainersL( aData );

    CreatePreprocessCommandsL( aData );

    CreateAnimationCommandsL( aData );

    CreateSizeBoundParamsL( aData );

    return ETrue;

    }

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

// CAknsAlAnimatorBmp::BeginConfigLayersL

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

//

void CAknsAlAnimatorBmp::BeginConfigLayersL( const TSize& aLayerSize,

                                             TDisplayMode aRgbMode )

    {

    if( RenderError() )

        User::Leave( iRenderError );

    // Make sure we have a valid size

    if( aLayerSize.iWidth < KAknsAlAnimMinimumWidth ||

        aLayerSize.iHeight < KAknsAlAnimMinimumHeight )

        User::Leave( KErrArgument );

    // Configure

    iContext->ConfigureL( aLayerSize, aRgbMode,

                          iInputLayerIndex,

                          iInputLayerMode );

    }

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

// CAknsAlAnimatorBmp::EndConfigLayersL

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

//

void CAknsAlAnimatorBmp::EndConfigLayersL( TBool aAboutToStart )

    {

    // Do the preprocessing step

    PreprocessL();

    // Because layer size may have changed and some layers may have been lost

    // we need to restart the animation (while preserving its state).

    TInt originalState = iState;

    if( EAknsAnimStateRunning == originalState )

        {

        // Starting will also stop animation first

        StartAnimationL( EFalse, ETrue );

        User::LeaveIfError( UpdateOutput() );

        }

    else // Animation must be stopped, paused or finished

        {

        // Starting will also stop animation first

        StartAnimationL( EFalse, EFalse );

        User::LeaveIfError( UpdateOutput() );

        iState = originalState;

        if( ( EAknsAnimStateStopped == originalState ) && !aAboutToStart )

            {

            // Stopping releases input layers and plugins

            StopAndRelease( ETrue, ETrue );

            }

        }

    // Check if we need to restore idling

    if( EAknsAnimStatePaused == iState && iIdling )

        {

        // Restart the idle timer

        if ( iTimer->IsActive() )

            {

            iTimer->Cancel();

            }

        iTimer->Start( 0, iIdlingInterval * 1000, TCallBack( TimerTimeoutCallback, this ) );

        }

    iSizeKnown = ETrue;

    }

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

// CAknsAlAnimatorBmp::StartAnimation

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

//

TInt CAknsAlAnimatorBmp::StartAnimation()

    {

    CancelIdling();

    if( RenderError() )

        {

        return iRenderError;

        }

    TRAPD( err, StartAnimationL( ETrue, ETrue ) );

    if( err )

        {

        StopAndRelease( ETrue, ETrue );

        return err;

        }

    iState = EAknsAnimStateRunning;

    return KErrNone;

    }

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

// CAknsAlAnimatorBmp::StopAnimation

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

//

TInt CAknsAlAnimatorBmp::StopAnimation()

    {

    CancelIdling();

    if( RenderError() )

        return iRenderError;

    if( EAknsAnimStatePaused == iState ||

        EAknsAnimStateRunning == iState ||

        EAknsAnimStateFinished == iState )

        {

        // Stopping releases input layers and plugins

        StopAndRelease( ETrue, ETrue );

        iState = EAknsAnimStateStopped;

        }

    return KErrNone;

    }

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

// CAknsAlAnimatorBmp::PauseAnimation

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

//

TInt CAknsAlAnimatorBmp::PauseAnimation()

    {

    CancelIdling();

    if( RenderError() )

        return iRenderError;

    if( EAknsAnimStateRunning == iState )

        {

        iTimer->Cancel();

        iState = EAknsAnimStatePaused;

        }

    return KErrNone;

    }

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

// CAknsAlAnimatorBmp::ContinueAnimationL

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

//

TInt CAknsAlAnimatorBmp::ContinueAnimation()

    {

    CancelIdling();

    if( RenderError() )

        return iRenderError;

    if( EAknsAnimStatePaused == iState )

        {

        iLastFrameTicks = User::TickCount();

        if ( iTimer->IsActive() )

            {

            iTimer->Cancel();

            }

        iTimer->Start( 0, iMinimumInterval * 1000, TCallBack( TimerTimeoutCallback, this ) );

        iState = EAknsAnimStateRunning;

        }

    return KErrNone;

    }

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

// CAknsAlAnimatorBmp::State

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

//

TInt CAknsAlAnimatorBmp::State() const

    {

    return iState;

    }