/*
* Copyright (c) 2005-2006 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:  Base class for all operation state machines
*
*/


#include "mdebug.h"
#include "rsfwrfestatemachine.h"
#include "rsfwinterface.h"
#include "rsfwfiletable.h"
#include "rsfwrferequest.h"
#include "rsfwfileengine.h"

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::BaseConstructL
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::BaseConstructL()
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::BaseConstructL"));
    iCompleteAndDestroyState =
        new (ELeave) CRsfwRfeStateMachine::TCompleteAndDestroyState(this);   
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::~CRsfwRfeStateMachine
// Note that normally when we come here iState = iCompleteAndDestroyState,
// only delete once
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::~CRsfwRfeStateMachine()
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::~CRsfwRfeStateMachine"));
    if (CurrentState() == CompleteAndDestroyState()) 
        {
        delete iState;
        }
    else 
        {
        delete iState;
        delete iCompleteAndDestroyState;
        }
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::ErrorOnStateEntry
// Entering the current state failed, so loop in EnterState() will replace 
// it by CompleteAndDestroy state as we return that state.
// Deleting the current state happens in EnterState()
// The state machine logic does not do that, as it allows us to eg resolve
// the problem by fixing the current state. 
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState* CRsfwRfeStateMachine::ErrorOnStateEntry(TInt aError) 
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::ErrorOnStateEntry"));
    iCompleteAndDestroyState->SetErrorCode(aError);
    return iCompleteAndDestroyState;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::ChangeState
// Enters aNextState, and makes it our current state.
// Deletes the previous state
// (assumes we never go backwards in the state machine)
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::ChangeState(CRsfwRfeStateMachine::TState* aNextState)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::ChangeState"));
    if (iState && (iState != aNextState) )
        {
        delete iState;
        iState = NULL;
        }
    EnterState(aNextState);
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::EnterState
// Enters aNextState, and makes it our current state.
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::EnterState(CRsfwRfeStateMachine::TState* aNextState)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::EnterState"));
    TInt err;
    while (aNextState) 
        {// State change required.
        iState = aNextState;
        TRAP(err, iState->EnterL());
        if (err)
            {
            aNextState = ErrorOnStateEntry(err);
            delete iState;
            iState = NULL;
            }
        else
            {
            aNextState = NULL;
            }
        }
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::SetNextState
// Sets the current state, but doesn't actually enter it.
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::SetNextState(TState* aNextState)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::SetNextState"));
    iState = aNextState;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::ReEnterCurrentState
// Re-enters the state we're currently in.
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::ReEnterCurrentState()  
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::ReEnterCurrentState"));
    EnterState(iState);
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::SetRequest
// Sets the backpointer to our request
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::SetRequest(CRsfwRfeRequest* aRequest)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::SetRequest"));
    iRFeRequest = aRequest;
    }
    
// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::Request 
// ----------------------------------------------------------------------------
//
CRsfwRfeRequest* CRsfwRfeStateMachine::Request()
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::Request"));
    return iRFeRequest;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::SetVolumes
// ----------------------------------------------------------------------------
//    
void CRsfwRfeStateMachine::SetVolumes(CRsfwVolumeTable* aImplementor)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::SetVolumes"));
    iImplementor = aImplementor;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::SetFileEngine
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::SetFileEngine(CRsfwFileEngine* aFileEngine) 
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::SetFileEngine"));
    iFileEngine = aFileEngine;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::SetArguments
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::SetArguments(TRfeInArgs* aInArgs, TRfeOutArgs* aOutArgs)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::SetArguments"));
    iInArgs = aInArgs;
    iOutArgs = aOutArgs;
    
    // Set the target node for this operation.
    if (iInArgs && iFileEngine) 
        {
        TFid* fidp = &(iInArgs->iFid);
        iFep = iFileEngine->iFileTable->Lookup(*fidp);  
        }
    else 
        {
        iFep = NULL;
        }
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::Volumes
// ----------------------------------------------------------------------------
//    
CRsfwVolumeTable* CRsfwRfeStateMachine::Volumes()
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::Volumes"));
    return iImplementor;
    }
  
// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::FileEngine
// ----------------------------------------------------------------------------
//    
CRsfwFileEngine* CRsfwRfeStateMachine::FileEngine()
    {
    return iFileEngine;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::Node
// ----------------------------------------------------------------------------
//
CRsfwFileEntry* CRsfwRfeStateMachine::Node() 
    {
    return iFep;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::ErrorOnStateExit
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState* CRsfwRfeStateMachine::ErrorOnStateExit(TInt aError) 
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::ErrorOnStateExit %d", aError));
    iCompleteAndDestroyState->SetErrorCode(aError);
    return iCompleteAndDestroyState;
    }
        
// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::HandleRemoteAccessResponse
// ----------------------------------------------------------------------------
//    
void CRsfwRfeStateMachine::HandleRemoteAccessResponse(TUint /*aId*/, TInt aStatus)
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::HandleRemoteAccessResponse"));
    TState* nextState = NULL;
    TRAPD(err, nextState = aStatus ? iState->ErrorL(aStatus)
          : iState->CompleteL());
    if (err)
        {
        nextState = ErrorOnStateExit(err);
        }
    ChangeState(nextState);
    }

// empty defaults for CRsfwRfeStateMachine::TState functions CompleteL(), ErrorL() and Cancel()

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::TState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState* CRsfwRfeStateMachine::TState::CompleteL()
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::TState::CompleteL"));
    return NULL;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::TState::ErrorL
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState* CRsfwRfeStateMachine::TState::ErrorL(TInt /*aCode*/) 
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::TState::ErrorL"));
    return NULL;
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::TState::Cancel
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::TState::Cancel() 
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::TState::Cancel"));
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::TCompleteAndDestroyState::TCompleteAndDestroyState
// Completes the remote request with error code aErrCode and
//  destroys it (CRsfwRfeRequest) 
// as well as the classes pointed to by it, that it the instances of 
// CRsfwRfeAsyncOperation, CRsfwRfeStateMachine and CRsfwRfeStateMachine::TState classes.
//
// In RemoteFS requests error code is 0,
// as the error is returned in iOutArgs->iResult
// For RemoteEngine API requests aErrCode should have the error code
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::
TCompleteAndDestroyState::TCompleteAndDestroyState(CRsfwRfeStateMachine* aParent,
                                                   TInt aErrCode)
    : iOperation(aParent), iErrCode(aErrCode)
    {
    DEBUGSTRING(("TCompleteAndDestroyState::TCompleteAndDestroyState"));
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::TCompleteAndDestroyState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::TCompleteAndDestroyState::EnterL()
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::TCompleteAndDestroyState::EnterL"));
    iOperation->Request()->CompleteAndDestroy(iErrCode);   
    // nothing can be called here as we have been deallocated!!!    
    }

// ----------------------------------------------------------------------------
// CRsfwRfeStateMachine::TCompleteAndDestroyState::SetErrorCode
// ----------------------------------------------------------------------------
//
void CRsfwRfeStateMachine::TCompleteAndDestroyState::SetErrorCode(TInt aErrorCode) 
    {
    DEBUGSTRING(("CRsfwRfeStateMachine::TCompleteAndDestroyState::SetErrorCode"));
    iErrCode = aErrorCode;
    }