/*

* Copyright (c) 2007 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 "rsfwflushstatemachine.h"

#include "rsfwinterface.h"

#include "rsfwfileentry.h"

#include "rsfwfileengine.h"

#include "rsfwrfeserver.h"

#include "rsfwvolumetable.h"

#include "rsfwfiletable.h"

#include "rsfwwaitnotemanager.h"

#include "rsfwvolume.h"

#include "mdebug.h"

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

// CRsfwFlushStateMachine::CRsfwFlushStateMachine

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

//

CRsfwFlushStateMachine::CRsfwFlushStateMachine()

    {

    }

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

// CRsfwFlushStateMachine::CompleteRequestL

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

//

CRsfwRfeStateMachine::TState*

CRsfwFlushStateMachine::CompleteRequestL(TInt aError) 

    {

     DEBUGSTRING(("CRsfwFlushStateMachine::CompleteRequestL()"));

    // If we just wrote the file to the server set attributes from the cache

    // file's attributes.Even if writing the file failed, attributes should

    // reflect the local modifications

    if (Node()->CacheFileName())

        {

        FileEngine()->SetupAttributes(*Node());

        }

    CompleteAndDestroyState()->SetErrorCode(aError);

    return CompleteAndDestroyState();   

    } 

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

// CRsfwFlushStateMachine::TFlushDataToServerState::TFlushDataToServerState

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

//

CRsfwFlushStateMachine::TFlushDataToServerState::TFlushDataToServerState(

    CRsfwFlushStateMachine* aParent)

    : iOperation(aParent)

    {

    }

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

// CRsfwFlushStateMachine::TFlushDataToServerState::EnterL

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

//

void CRsfwFlushStateMachine::TFlushDataToServerState::EnterL() 

    {

    DEBUGSTRING(("CRsfwFlushStateMachine::TFlushDataToServerState::EnterL()"));

    TDesC* cacheNamep;

    if (!iOperation->Node())

        {

        User::Leave(KErrNotFound);

        }

    TRfeFlushInArgs* inArgs =

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

    if (iOperation->Node()->IsCancelled()) 

        {

        // user has cancelled writing this file to server even before we got to flush

        // (when the file was being written to the local cache)

        iOperation->HandleRemoteAccessResponse(0, KErrCancel);

        }

    else 

        {

        TInt firstByte = inArgs->iFirstByte;

        TInt dataLength = inArgs->iDataLength;

        TInt totalSize = inArgs->iTotalSize;  

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

        _LIT8(KTextPlain, "text/plain");

        HBufC* fullName =

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

        // get the MIME-type of the file

        HBufC8* contentType = iOperation->FileEngine()->GetContentType(*cacheNamep);

        if (contentType) 

            {

            CleanupStack::PushL(contentType);  

            }

        else 

            {

            contentType = KTextPlain().AllocLC();

            }

        if  ((firstByte == 0) &&

            (dataLength == totalSize)) 

            {

            // non-partial put

            TUint transactionId 

                = iOperation->FileEngine()->RemoteAccessL()->PutFileL(*cacheNamep,

                                                            *fullName,

                                                            *contentType,

                                                            iOperation);

            }

        else 

            {

            // partial put

            TUint transactionId 

            = iOperation->FileEngine()->RemoteAccessL()->PutFileL(*cacheNamep,

                                                            *fullName,

                                                            *contentType,

                                                            firstByte,

                                                   dataLength-firstByte,

                                                            totalSize,

                                                            iOperation);

            }

        CleanupStack::PopAndDestroy(2); // fullName, contentType        

        }

    }

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

// CRsfwFlushStateMachine::TFlushDataToServerState::CompleteL

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

//

CRsfwRfeStateMachine::TState*

CRsfwFlushStateMachine::TFlushDataToServerState::CompleteL()

    {  

    DEBUGSTRING(("CRsfwFlushStateMachine::TFlushDataToServerState::CompleteL()"));

  	return iOperation->CompleteRequestL(KErrNone); 

    }

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

// CRsfwFlushStateMachine::TFlushDataToServerState::ErrorL

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

//    

CRsfwRfeStateMachine::TState*

CRsfwFlushStateMachine::TFlushDataToServerState::ErrorL(TInt aCode)

    {

    DEBUGSTRING(("CRsfwFlushStateMachine::TFlushDataToServerState::ErrorL() %d", aCode));

  	return iOperation->CompleteRequestL(aCode); 

    }

// End of file