/*

* 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:  State machine for fetching data without caching it permanently

*

*/

#include "rsfwfetchdatastatemachine.h"

#include "rsfwfileentry.h"

#include "rsfwfiletable.h"

#include "rsfwinterface.h"

#include "rsfwvolumetable.h"

#include "rsfwvolume.h"

#include "rsfwrfeserver.h"

#include "mdebug.h"

#include "rsfwfileengine.h"

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

// CRsfwFetchDataStateMachine::CRsfwFetchDataStateMachine

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

//

CRsfwFetchDataStateMachine::CRsfwFetchDataStateMachine()

    {

    }

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

// CRsfwFetchDataStateMachine::CompleteRequestL

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

//

CRsfwRfeStateMachine::TState*

CRsfwFetchDataStateMachine::CompleteRequestL(TInt aError) 

    {

    TRfeFetchDataOutArgs* outArgs =

        static_cast<TRfeFetchDataOutArgs*>(iOutArgs);

    if(!aError) 

        {

        outArgs->iTempPath.Copy(*iCacheName);

        }

    CompleteAndDestroyState()->SetErrorCode(aError);

    return CompleteAndDestroyState();   

    } 

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

// CRsfwFetchDataStateMachine::TFetchDataState::TFetchDataState

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

//

CRsfwFetchDataStateMachine::TFetchDataState::TFetchDataState(

    CRsfwFetchDataStateMachine* aParent)

    : iOperation(aParent)

    {

    }

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

// CRsfwFetchDataStateMachine::TFetchDataState::EnterL

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

//

void CRsfwFetchDataStateMachine::TFetchDataState::EnterL() 

    {

    TInt err = KErrNone;

    TRfeFetchDataInArgs* inArgs =

        static_cast<TRfeFetchDataInArgs*>(iOperation->iInArgs);

    TRfeFetchDataOutArgs* outArgs =

        static_cast<TRfeFetchDataOutArgs*>(iOperation->iOutArgs);

    TInt firstByte = inArgs->iFirstByte;

    TInt lastByte = inArgs->iLastByte;

    TCachingMode cachingMode =

        iOperation->Node()->iFileTable->Volume()->iVolumeTable->iCachingMode;

    if (iOperation->Node())

        {

        DEBUGSTRING(("Fetch without caching fid %d, bytes %d - %d",

                     iOperation->Node()->Fid().iNodeId,

                     firstByte,

                     lastByte));

        if (cachingMode == EWholeFileCaching) 

            {

            outArgs->iUseTempPath = EFalse; 

            // in this mode we always fetch the whole file to the normal cache

            iOperation->iCacheName = iOperation->Node()->CacheFileName();

            iOperation->iLength = iOperation->Node()->Size() -

                iOperation->Node()->iCachedSize +

                1;

            TUint transactionId = iOperation->

                FileEngine()->FetchAndCacheL(*iOperation->Node(), 

                                             iOperation->Node()->iCachedSize, 

                                             &iOperation->iLength,

                                             &(iOperation->iDirEnts),

                                             iOperation); 

            // transactionId = 0 means syncronous non-cancellable operation    

    		if (transactionId > 0) 

   				{

    			iOperation->iTransactionId = transactionId;

    			}      

            }

        else 

            {

            // reset and use the temporary cache file...

            outArgs->iUseTempPath = ETrue;

            TParse parser;

            parser.Set(*iOperation->Node()->CacheFileName(), NULL, NULL);

            HBufC* tempPath = HBufC::NewLC(KMaxPath);

            TPtr tempfile = tempPath->Des();

            tempfile.Append(parser.DriveAndPath());

            tempfile.Append(KTempFileName);

            iOperation->iCacheName = iOperation->Node()->CacheFileName();

            // This much will be added to the cache by this fetch

            iOperation->iLength =lastByte - firstByte + 1;

            if (!iOperation->

                Node()->

                iFileTable->

                Volume()->

                iVolumeTable->EnsureCacheCanBeAddedL(iOperation->iLength))

                {

                User::Leave(KErrDiskFull);  

                }

            RFile f;

            err = f.Replace(CRsfwRfeServer::Env()->iFs,

                            *tempPath,

                            EFileShareAny | EFileWrite);

            if (err == KErrNone)

                {

                f.Close();

                HBufC* fullName =

                    iOperation->FileEngine()->FullNameLC(*iOperation->Node());

                TUint transactionId = iOperation->FileEngine()->RemoteAccessL()->

                    GetFileL(*fullName,

                             *tempPath,

                             firstByte,

                             &iOperation->iLength,

                             KRemoteAccessOptionGetToStartOfFile,

                             iOperation);  

                // transactionId = 0 means syncronous non-cancellable operation     

    			if (transactionId > 0) 

   					{

    				iOperation->iTransactionId = transactionId;

    				}              

                CleanupStack::PopAndDestroy(fullName);

                }

            CleanupStack::PopAndDestroy(tempPath);   

            }

        }

    }

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

// CRsfwFetchDataStateMachine::TFetchDataState::CompleteL

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

//

CRsfwFetchDataStateMachine::TState*

CRsfwFetchDataStateMachine::TFetchDataState::CompleteL()

    {      

    return iOperation->CompleteRequestL(KErrNone); 

    }

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

// CRsfwFetchDataStateMachine::TFetchDataState::ErrorL

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

//    

CRsfwFetchDataStateMachine::TState*

CRsfwFetchDataStateMachine::TFetchDataState::ErrorL(TInt aCode)

    {

    return iOperation->CompleteRequestL(aCode); 

    }