/*
* 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