/*

* Copyright (c) 2002-2005 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:    StateMachine for payloadformat plugins.

*

*/

// INCLUDE FILES

#include "formatstatemachine.h"

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CFormatEncodeStateMachine::CFormatEncodeStateMachine

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

// might leave

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

//

CFormatEncodeStateMachine::CFormatEncodeStateMachine( 

    MPayloadFormatWrite* aClient ) : CActive( EPriorityStandard ),

    iClient( aClient ), iState( EEncodeIdle )

    {

    CActiveScheduler::Add( this );

    }

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

// CFormatEncodeStateMachine::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CFormatEncodeStateMachine::ConstructL()

    {

    User::LeaveIfNull( iClient );

    }

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

// CFormatEncodeStateMachine::NewL

// Static constructor.

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

//

CFormatEncodeStateMachine* CFormatEncodeStateMachine::NewL( 

    MPayloadFormatWrite* aClient )

    {

    CFormatEncodeStateMachine* self = 

            new ( ELeave ) CFormatEncodeStateMachine( aClient );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFormatEncodeStateMachine::~CFormatEncodeStateMachine

// Destructor

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

//

CFormatEncodeStateMachine::~CFormatEncodeStateMachine()

    {

    Cancel();

    }

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

// CFormatEncodeStateMachine::ChangeState

// Changes state

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

//

void CFormatEncodeStateMachine::ChangeState( TFormatEncodeState aNewState )

    {

    // Observe the transition rules

    TBool changeState = EFalse;

    switch ( aNewState )

        {

        case EEncodeIdle:

            // Can change to EEncodeIdle state from any other state.

            changeState = ETrue;

            break;

        case EEmptySourceBuffer:

            if ( ESourceBufferEmptied == iState || EEncodeIdle == iState )

                {

                changeState = ETrue;

                }

            break;

        case ESourceBufferEmptied:

            if ( EEmptySourceBuffer == iState )

                {

                changeState = ETrue;

                }

            break;

        default:

            break;

        }

    // Change the state if everything is OK.

    if ( changeState )

        {

        iState = aNewState;

        // Idle states, no callbacks to client, thus no need for activation.

        if ( EEncodeIdle != iState )

            {

            TRequestStatus* stat = &iStatus;

            Cancel();

            User::RequestComplete( stat, KErrNone );

            SetActive();

            }

        }

    }

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

// CFormatEncodeStateMachine::CurrentState

// Returns the current state

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

//

TFormatEncodeState CFormatEncodeStateMachine::CurrentState() const

    {

    return iState;

    }

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

// CFormatEncodeStateMachine::RunL

// From CActive Handles an active object’s request completion event.

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

//

void CFormatEncodeStateMachine::RunL()

    {

    if ( KErrNone == iStatus.Int() )

        {

        switch ( iState )

            {

            case EEncodeIdle:

                // Do nothing but wait.

                break;

            case EEmptySourceBuffer:

                iClient->EmptySourceBufferL();

                break;

            case ESourceBufferEmptied:

                iClient->SourceBufferEmptiedL();

                break;

            default:

                User::Leave( KErrArgument );

                break;

            }

        }

    else

        {

        User::Leave( iStatus.Int() );

        }

    }

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

// CFormatEncodeStateMachine::DoCancel

// From CActive Implements cancellation of an outstanding request.

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

//

void CFormatEncodeStateMachine::DoCancel()

    {

    }

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

// CFormatEncodeStateMachine::RunError

// Handle the leave occured in RunL() function

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

//

TInt CFormatEncodeStateMachine::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    };

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

// CFormatDecodeStateMachine::CFormatDecodeStateMachine

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

// might leave

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

//

CFormatDecodeStateMachine::CFormatDecodeStateMachine( 

    MPayloadFormatRead* aClient ) : CActive( EPriorityStandard ),

    iClient( aClient ), iState( EDecodeIdle )

    {

    CActiveScheduler::Add( this );

    }

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

// CFormatDecodeStateMachine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CFormatDecodeStateMachine::ConstructL()

    {

    User::LeaveIfNull( iClient );

    }

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

// CFormatDecodeStateMachine::NewL

// Static constructor.

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

//

CFormatDecodeStateMachine* CFormatDecodeStateMachine::NewL( 

    MPayloadFormatRead* aClient )

    {

    CFormatDecodeStateMachine* self = 

            new ( ELeave ) CFormatDecodeStateMachine( aClient );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFormatDecodeStateMachine::~CFormatDecodeStateMachine

// Destructor

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

//

CFormatDecodeStateMachine::~CFormatDecodeStateMachine()

    {

    Cancel();

    }

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

// CFormatDecodeStateMachine::ChangeState

// Change State

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

//

void CFormatDecodeStateMachine::ChangeState( TFormatDecodeState aNewState )

    {

    // Observe the state transition rules.

    TBool changeState = EFalse;

    switch ( aNewState )

        {

        // These state transitions allowed from all states.

        case EDecodeIdle:

        case ESourceDataReady:

            changeState = ETrue;

            break;

        case EEmptyDataToSink:

            if ( ESourceDataReady == iState || EEmptyDataToSink == iState )

                {

                changeState = ETrue;

                }

            break;

        default:

            break;

        }

    if ( changeState )

        {

        iState = aNewState;

        // Idle state, no callbacks to client, thus no need for activation.

        if ( EDecodeIdle != iState )

            {

            TRequestStatus* stat = &iStatus;

            Cancel();

            User::RequestComplete( stat, KErrNone );

            SetActive();

            }

        }

    }

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

// CFormatDecodeStateMachine::CurrentState

// Get current state

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

//

TFormatDecodeState CFormatDecodeStateMachine::CurrentState() const

    {

    return iState;

    }

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

// CFormatDecodeStateMachine::RunL

// From CActive Handles an active object’s request completion event.

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

//

void CFormatDecodeStateMachine::RunL()

    {

    if ( KErrNone == iStatus.Int() )

        {

        switch ( iState )

            {

            case EDecodeIdle: 

                // TBD: Do idle processing.

                break;

            case ESourceDataReady:

                iClient->FillSinkBufferL();

                break;

            case EEmptyDataToSink:

                iClient->SendDataToSinkL();

                break;

            default:

                User::Leave( KErrArgument );

                break;

            }

        }

    else

        {

        User::Leave( iStatus.Int() );

        }

    };

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

// CFormatDecodeStateMachine::DoCancel

// From CActive Implements cancellation of an outstanding request.

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

//

void CFormatDecodeStateMachine::DoCancel()

    {

    };

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

// CFormatDecodeStateMachine::RunError

// Handle the leave occured in RunL() function

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

//

TInt CFormatDecodeStateMachine::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    };

//  End of File